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

package/dist/cli.js

@@ -10,6 +10,243 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/cli/generators/claude-md.ts
+var claude_md_exports = {};
+__export(claude_md_exports, {
+  generateClaudeMd: () => generateClaudeMd,
+  generateCursorRules: () => generateCursorRules,
+  generateSchemockSection: () => generateSchemockSection,
+  mergeClaudeMdContent: () => mergeClaudeMdContent,
+  validateExistingContent: () => validateExistingContent
+});
+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");
+}
+var SECTION_START_MARKER, SECTION_END_MARKER;
+var init_claude_md = __esm({
+  "src/cli/generators/claude-md.ts"() {
+    "use strict";
+    SECTION_START_MARKER = "<!-- SCHEMOCK:START - AI instructions for Schemock. Do not remove this marker -->";
+    SECTION_END_MARKER = "<!-- SCHEMOCK:END -->";
+  }
+});
+
 // src/cli/config.ts
 function validateConfig(config, filePath) {
   const result = SchemockConfigSchema.safeParse(config);
@@ -4435,6 +4672,313 @@ var init_hooks = __esm({
   }
 });
 
+// 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, field);
+  }
+  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();
+}
+var init_form_schemas = __esm({
+  "src/cli/generators/form-schemas.ts"() {
+    "use strict";
+    init_code_builder();
+  }
+});
+
 // src/cli/generators/nextjs-api/route-template.ts
 function generateRouteFile(schema, target, _config) {
   const hasAuth = target.middleware?.auth !== void 0;
@@ -6542,10 +7086,14 @@ async function generate(options) {
   if (analyzedEndpoints.length > 0) {
     typesCode += generateEndpointTypes(analyzedEndpoints);
   }
+  if (options.withFormSchemas) {
+    typesCode += generateFormSchemas(analyzed);
+  }
   await writeOutput4((0, import_node_path6.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) {
@@ -6711,6 +7259,7 @@ var init_generate = __esm({
     init_client4();
     init_pglite();
     init_hooks();
+    init_form_schemas();
     init_target_registry();
   }
 });
@@ -6750,7 +7299,7 @@ function fieldToPgColumn(field) {
     parts.push("UNIQUE");
   }
   if (field.hasDefault && field.defaultValue !== void 0) {
-    const defaultVal = formatDefaultValue2(field.defaultValue, field);
+    const defaultVal = formatDefaultValue3(field.defaultValue, field);
     if (defaultVal !== null) {
       parts.push(`DEFAULT ${defaultVal}`);
     }
@@ -6761,7 +7310,7 @@ function fieldToPgColumn(field) {
   }
   return parts.join(" ");
 }
-function formatDefaultValue2(value, field) {
+function formatDefaultValue3(value, field) {
   if (value === void 0 || value === null) {
     return field.nullable ? "NULL" : null;
   }
@@ -8562,9 +9111,113 @@ var init_generator = __esm({
   }
 });
 
+// src/cli/commands/setup-ai.ts
+var setup_ai_exports = {};
+__export(setup_ai_exports, {
+  setupAI: () => setupAI
+});
+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 = (0, import_node_path8.resolve)(outputDir, "CLAUDE.md");
+  let existingContent = "";
+  if ((0, import_node_fs2.existsSync)(claudeMdPath)) {
+    console.log("\u{1F4C4} Found existing CLAUDE.md");
+    existingContent = (0, import_node_fs2.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) {
+    (0, import_node_fs2.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 = (0, import_node_path8.resolve)(outputDir, ".cursorrules");
+    const cursorExists = (0, import_node_fs2.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 = (0, import_node_fs2.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) {
+        (0, import_node_fs2.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
+  };
+}
+var import_node_fs2, import_node_path8;
+var init_setup_ai = __esm({
+  "src/cli/commands/setup-ai.ts"() {
+    "use strict";
+    import_node_fs2 = require("fs");
+    import_node_path8 = require("path");
+    init_config();
+    init_claude_md();
+  }
+});
+
 // src/cli.ts
-var import_node_fs2 = require("fs");
-var import_node_path8 = require("path");
+var import_node_fs3 = require("fs");
+var import_node_path9 = require("path");
 function parseArgs(args) {
   const options = {};
   const positional = [];
@@ -8601,6 +9254,12 @@ function parseArgs(args) {
       options.exclude = args[++i].split(",");
     } else if (arg === "--readme") {
       options.readme = true;
+    } else if (arg === "--with-form-schemas") {
+      options.withFormSchemas = true;
+    } else if (arg === "--cursor") {
+      options.cursor = true;
+    } else if (arg === "--force") {
+      options.force = true;
     } else if (!arg.startsWith("-")) {
       positional.push(arg);
     }
@@ -8622,6 +9281,7 @@ Commands:
                                    Generate OpenAPI 3.0 specification
   generate:postman [--output <file>]
                                    Generate Postman collection
+  setup:ai [options]               Generate CLAUDE.md for AI tool integration
   help                             Show this help message
   version                          Show version
 
@@ -8633,6 +9293,8 @@ Generate Options:
                           Applies to ALL targets, overrides config
   --exclude <entities>    Exclude these entities (comma-separated)
                           Applies to ALL targets, overrides config
+  --with-form-schemas     Generate Zod validation schemas, form defaults,
+                          and table column metadata
   --watch, -w             Watch mode - regenerate on schema changes
   --dry-run               Show what would be generated without writing files
   --verbose, -v           Verbose output
@@ -8646,6 +9308,11 @@ SQL Generation Options (generate:sql):
   --readme                Generate README.md documentation
   --dry-run               Show what would be generated without writing files
 
+AI Setup Options (setup:ai):
+  --cursor                Also generate .cursorrules for Cursor IDE
+  --force                 Overwrite existing files without checking
+  --dry-run               Show what would be generated without writing
+
 Other Options:
   --format, -f <format>   Output format (json, yaml) for OpenAPI
   --template, -t <name>   Template name for init
@@ -8662,6 +9329,9 @@ Examples:
   schemock generate:sql --only tables,indexes,rls
   schemock generate:openapi --output api.yaml --format yaml
   schemock generate:postman --output collection.json
+  schemock setup:ai                            # Generate CLAUDE.md
+  schemock setup:ai --cursor                   # Also generate .cursorrules
+  schemock setup:ai --dry-run                  # Preview without writing
 
 Entity Filtering (in config):
   targets: [
@@ -8672,9 +9342,9 @@ Entity Filtering (in config):
 }
 function showVersion() {
   try {
-    const pkgPath = (0, import_node_path8.resolve)(__dirname, "../package.json");
-    if ((0, import_node_fs2.existsSync)(pkgPath)) {
-      const pkg = JSON.parse((0, import_node_fs2.readFileSync)(pkgPath, "utf-8"));
+    const pkgPath = (0, import_node_path9.resolve)(__dirname, "../package.json");
+    if ((0, import_node_fs3.existsSync)(pkgPath)) {
+      const pkg = JSON.parse((0, import_node_fs3.readFileSync)(pkgPath, "utf-8"));
       console.log(`schemock v${pkg.version}`);
       return;
     }
@@ -8689,13 +9359,13 @@ Initializing Schemock project with template: ${template}
 `);
   const dirs = ["src/schemas"];
   for (const dir of dirs) {
-    if (!(0, import_node_fs2.existsSync)(dir)) {
-      (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
+    if (!(0, import_node_fs3.existsSync)(dir)) {
+      (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
       console.log(`  Created ${dir}/`);
     }
   }
   const schemaPath = "src/schemas/user.ts";
-  if (!(0, import_node_fs2.existsSync)(schemaPath)) {
+  if (!(0, import_node_fs3.existsSync)(schemaPath)) {
     const schemaContent = `import { defineData, field, hasMany, belongsTo } from 'schemock/schema';
 
 /**
@@ -8739,11 +9409,17 @@ export const commentSchema = defineData('comment', {
   },
 });
 `;
-    (0, import_node_fs2.writeFileSync)(schemaPath, schemaContent);
+    (0, import_node_fs3.writeFileSync)(schemaPath, schemaContent);
     console.log(`  Created ${schemaPath}`);
   }
   const configPath = "schemock.config.ts";
-  if (!(0, import_node_fs2.existsSync)(configPath)) {
+  const defaultConfig = {
+    schemas: "./src/schemas/**/*.ts",
+    output: "./src/generated",
+    adapter: "mock",
+    apiPrefix: "/api"
+  };
+  if (!(0, import_node_fs3.existsSync)(configPath)) {
     const configContent = `import { defineConfig } from 'schemock/cli';
 
 export default defineConfig({
@@ -8780,15 +9456,37 @@ export default defineConfig({
   },
 });
 `;
-    (0, import_node_fs2.writeFileSync)(configPath, configContent);
+    (0, import_node_fs3.writeFileSync)(configPath, configContent);
     console.log(`  Created ${configPath}`);
   }
+  console.log("\n\u{1F916} Setting up AI configuration...");
+  const { generateClaudeMd: generateClaudeMd2 } = await Promise.resolve().then(() => (init_claude_md(), claude_md_exports));
+  const claudeMdPath = (0, import_node_path9.resolve)("CLAUDE.md");
+  let existingClaudeMd = "";
+  if ((0, import_node_fs3.existsSync)(claudeMdPath)) {
+    existingClaudeMd = (0, import_node_fs3.readFileSync)(claudeMdPath, "utf-8");
+  }
+  const claudeResult = generateClaudeMd2(defaultConfig, existingClaudeMd);
+  if (claudeResult.modified || claudeResult.created) {
+    (0, import_node_fs3.writeFileSync)(claudeMdPath, claudeResult.content, "utf-8");
+    if (claudeResult.created) {
+      console.log("  Created CLAUDE.md");
+    } else {
+      console.log("  Updated CLAUDE.md (added Schemock section)");
+    }
+  } else {
+    console.log("  CLAUDE.md already has Schemock configuration");
+  }
   console.log("\n\u2713 Schemock initialized successfully!\n");
   console.log("Next steps:");
   console.log("  1. Review and customize schemas in src/schemas/");
   console.log("  2. Run: npx schemock generate");
   console.log("  3. Import { useUsers, useCreateUser } from ./src/generated");
   console.log("");
+  console.log("AI Integration:");
+  console.log("  \u2022 CLAUDE.md helps Claude Code understand your project");
+  console.log('  \u2022 Run "npx schemock setup:ai --cursor" for Cursor IDE support');
+  console.log("");
 }
 async function generateCommand(options) {
   const { generate: generate2 } = await Promise.resolve().then(() => (init_generate(), generate_exports));
@@ -8800,7 +9498,8 @@ async function generateCommand(options) {
     dryRun: options.dryRun,
     verbose: options.verbose,
     only: options.only,
-    exclude: options.exclude
+    exclude: options.exclude,
+    withFormSchemas: options.withFormSchemas
   });
 }
 async function generateSQLCommand(options) {
@@ -8835,7 +9534,7 @@ async function generateOpenAPICommand(options) {
 `);
     return;
   }
-  const outputPath = (0, import_node_path8.resolve)(options.output);
+  const outputPath = (0, import_node_path9.resolve)(options.output);
   const format = options.format || (outputPath.endsWith(".yaml") || outputPath.endsWith(".yml") ? "yaml" : "json");
   const spec = generateOpenAPI2({
     title: "API Documentation",
@@ -8843,11 +9542,21 @@ async function generateOpenAPICommand(options) {
     description: "Generated by Schemock"
   });
   const output = format === "yaml" ? toYAML(spec) : JSON.stringify(spec, null, 2);
-  (0, import_node_fs2.mkdirSync)((0, import_node_path8.dirname)(outputPath), { recursive: true });
-  (0, import_node_fs2.writeFileSync)(outputPath, output);
+  (0, import_node_fs3.mkdirSync)((0, import_node_path9.dirname)(outputPath), { recursive: true });
+  (0, import_node_fs3.writeFileSync)(outputPath, output);
   console.log(`  Generated: ${outputPath}`);
   console.log("\n\u2713 OpenAPI specification generated successfully!\n");
 }
+async function setupAICommand(options) {
+  const { setupAI: setupAI2 } = await Promise.resolve().then(() => (init_setup_ai(), setup_ai_exports));
+  await setupAI2({
+    config: options.config,
+    cursor: options.cursor,
+    force: options.force,
+    dryRun: options.dryRun,
+    output: options.output
+  });
+}
 async function generatePostmanCommand(options) {
   const { generatePostmanCollection: generatePostmanCollection2, registerSchemasForPostman: registerSchemasForPostman2 } = await Promise.resolve().then(() => (init_generator(), generator_exports));
   console.log("\nGenerating Postman collection...");
@@ -8867,14 +9576,14 @@ async function generatePostmanCommand(options) {
 `);
     return;
   }
-  const outputPath = (0, import_node_path8.resolve)(options.output);
+  const outputPath = (0, import_node_path9.resolve)(options.output);
   const collection = generatePostmanCollection2({
     name: "API Collection",
     baseUrl: "http://localhost:3000",
     description: "Generated by Schemock"
   });
-  (0, import_node_fs2.mkdirSync)((0, import_node_path8.dirname)(outputPath), { recursive: true });
-  (0, import_node_fs2.writeFileSync)(outputPath, JSON.stringify(collection, null, 2));
+  (0, import_node_fs3.mkdirSync)((0, import_node_path9.dirname)(outputPath), { recursive: true });
+  (0, import_node_fs3.writeFileSync)(outputPath, JSON.stringify(collection, null, 2));
   console.log(`  Generated: ${outputPath}`);
   console.log("\n\u2713 Postman collection generated successfully!\n");
 }
@@ -8940,6 +9649,9 @@ async function main() {
     case "generate:sql":
       await generateSQLCommand(options);
       break;
+    case "setup:ai":
+      await setupAICommand(options);
+      break;
     default:
       console.error(`Unknown command: ${command}`);
       console.log('Run "schemock help" for usage information.');