@claudetools/tools 0.9.0 → 0.9.2

package/dist/codegen/natural-parser.js

@@ -0,0 +1,769 @@
+// =============================================================================
+// Natural Language → Kappa AST Parser
+// =============================================================================
+//
+// Converts natural language entity descriptions into Kappa AST.
+// No DSL syntax required - just describe what you want.
+//
+// Examples:
+//   "User with email, password, role (admin/user)"
+//   "Post with title, content, published, belongs to User as author"
+//   "Comment with body, approved, belongs to User, belongs to Post"
+//
+import { inferFieldType, parseInlineEnum, parseExplicitType } from './field-inference.js';
+const PRIMITIVE_TYPES = [
+    'string', 'int', 'float', 'bool', 'email', 'url', 'uuid',
+    'phone', 'slug', 'markdown', 'json', 'timestamp', 'date', 'time', 'duration'
+];
+/**
+ * Parse natural language description into Kappa entities
+ */
+export function parseNaturalLanguage(description) {
+    const errors = [];
+    const entities = [];
+    // Split by entity boundaries (look for "Entity with" pattern)
+    const entityBlocks = splitIntoEntities(description);
+    for (const block of entityBlocks) {
+        try {
+            const entity = parseEntityBlock(block);
+            entities.push(entity);
+        }
+        catch (e) {
+            errors.push(e instanceof Error ? e.message : String(e));
+        }
+    }
+    return {
+        success: errors.length === 0 && entities.length > 0,
+        entities,
+        components: [], // TODO: Will be populated when component parser is added
+        errors,
+    };
+}
+/**
+ * Split description into entity blocks
+ */
+function splitIntoEntities(description) {
+    // Pattern: EntityName with/has ...
+    const pattern = /([A-Z][a-zA-Z]*)\s+(?:with|has|having)\s+/gi;
+    const matches = [...description.matchAll(pattern)];
+    if (matches.length === 0) {
+        // Try simpler pattern: just EntityName followed by fields
+        const simpleMatch = description.match(/^([A-Z][a-zA-Z]*)\s*[:\-]?\s*(.+)$/);
+        if (simpleMatch) {
+            return [description];
+        }
+        return [];
+    }
+    const blocks = [];
+    for (let i = 0; i < matches.length; i++) {
+        const start = matches[i].index;
+        const end = i < matches.length - 1 ? matches[i + 1].index : description.length;
+        blocks.push(description.slice(start, end).trim());
+    }
+    return blocks;
+}
+/**
+ * Parse a single entity block
+ */
+function parseEntityBlock(block) {
+    // Extract entity name
+    const nameMatch = block.match(/^([A-Z][a-zA-Z]*)/);
+    if (!nameMatch) {
+        throw new Error(`Could not find entity name in: ${block}`);
+    }
+    const entityName = nameMatch[1];
+    // Extract fields part (after "with" or "has" or ":")
+    const fieldsMatch = block.match(/(?:with|has|having|:)\s*(.+)$/i);
+    if (!fieldsMatch) {
+        throw new Error(`Could not find fields in: ${block}`);
+    }
+    const fieldsStr = fieldsMatch[1];
+    const { fields, relationships } = parseFieldsList(fieldsStr, entityName);
+    // Auto-add id if not present
+    const hasId = fields.some(f => f.name === 'id');
+    if (!hasId) {
+        fields.unshift(createField('id', 'uuid', ['primary', 'auto']));
+    }
+    // Auto-add timestamps if entity has content fields
+    const hasContent = fields.some(f => ['content', 'body', 'title', 'headline'].includes(f.name));
+    const hasCreatedAt = fields.some(f => f.name === 'createdAt');
+    if (hasContent && !hasCreatedAt) {
+        fields.push(createField('createdAt', 'timestamp', ['auto']));
+        fields.push(createField('updatedAt', 'timestamp', ['auto']));
+    }
+    return {
+        kind: 'EntityBlock',
+        name: entityName,
+        fields,
+        relationships,
+        capabilities: [],
+        lifecycleHooks: [],
+        indexes: [],
+        loc: { startLine: 1, startColumn: 1, endLine: 1, endColumn: 1, startOffset: 0, endOffset: 0 },
+    };
+}
+/**
+ * Parse comma-separated fields list
+ */
+function parseFieldsList(fieldsStr, entityName) {
+    const fields = [];
+    const relationships = [];
+    // Split by comma, but not inside parentheses
+    const parts = smartSplit(fieldsStr, ',');
+    for (const part of parts) {
+        const trimmed = part.trim();
+        if (!trimmed)
+            continue;
+        // Check for relationship
+        const rel = parseRelationship(trimmed);
+        if (rel) {
+            relationships.push(rel);
+            continue;
+        }
+        // Check for enum notation: "role (admin, user, guest)"
+        const enumMatch = parseInlineEnum(trimmed);
+        if (enumMatch) {
+            fields.push(createEnumField(enumMatch.name, enumMatch.values));
+            continue;
+        }
+        // Check for explicit type: "age:int" or "name:string:optional"
+        const explicit = parseExplicitType(trimmed);
+        if (explicit) {
+            fields.push(createFieldFromExplicit(explicit.name, explicit.type));
+            continue;
+        }
+        // Infer from field name - strip any trailing type-like suffixes that weren't parsed
+        const cleanedField = trimmed.replace(/[.,;!?]+$/, '').trim();
+        // If there's a colon that wasn't parsed as explicit type, take only the name part
+        const fieldName = cleanedField.includes(':')
+            ? cleanedField.split(':')[0].replace(/[^a-zA-Z0-9]/g, '')
+            : cleanedField.replace(/[^a-zA-Z0-9]/g, '');
+        if (fieldName) {
+            const inferred = inferFieldType(fieldName);
+            fields.push(createField(fieldName, inferred.type, inferred.modifiers));
+        }
+    }
+    return { fields, relationships };
+}
+/**
+ * Parse relationship notation
+ * Examples: "belongs to User", "has many Posts", "belongs to User as author"
+ */
+function parseRelationship(text) {
+    // belongs_to: "belongs to Entity (as alias)"
+    const belongsMatch = text.match(/^belongs\s+to\s+([A-Z][a-zA-Z]*)(?:\s+as\s+(\w+))?$/i);
+    if (belongsMatch) {
+        return {
+            kind: 'EntityRelationship',
+            type: 'belongs_to',
+            entity: belongsMatch[1],
+            as: belongsMatch[2],
+            loc: { startLine: 1, startColumn: 1, endLine: 1, endColumn: 1, startOffset: 0, endOffset: 0 },
+        };
+    }
+    // has_many: "has many Entities"
+    const hasManyMatch = text.match(/^has\s+many\s+([A-Z][a-zA-Z]*)$/i);
+    if (hasManyMatch) {
+        return {
+            kind: 'EntityRelationship',
+            type: 'has_many',
+            entity: hasManyMatch[1],
+            loc: { startLine: 1, startColumn: 1, endLine: 1, endColumn: 1, startOffset: 0, endOffset: 0 },
+        };
+    }
+    // has_one: "has one Profile"
+    const hasOneMatch = text.match(/^has\s+one\s+([A-Z][a-zA-Z]*)$/i);
+    if (hasOneMatch) {
+        return {
+            kind: 'EntityRelationship',
+            type: 'has_one',
+            entity: hasOneMatch[1],
+            loc: { startLine: 1, startColumn: 1, endLine: 1, endColumn: 1, startOffset: 0, endOffset: 0 },
+        };
+    }
+    return null;
+}
+/**
+ * Create a field with primitive type
+ */
+function createField(name, typeName, modifiers) {
+    // Normalize type name
+    const normalizedType = normalizeTypeName(typeName);
+    const fieldType = {
+        kind: 'primitive',
+        type: normalizedType,
+    };
+    return {
+        kind: 'EntityField',
+        name,
+        type: fieldType,
+        modifiers: modifiers,
+        loc: { startLine: 1, startColumn: 1, endLine: 1, endColumn: 1, startOffset: 0, endOffset: 0 },
+    };
+}
+/**
+ * Create an enum field
+ */
+function createEnumField(name, values) {
+    return {
+        kind: 'EntityField',
+        name,
+        type: {
+            kind: 'enum',
+            values,
+        },
+        modifiers: [],
+        loc: { startLine: 1, startColumn: 1, endLine: 1, endColumn: 1, startOffset: 0, endOffset: 0 },
+    };
+}
+/**
+ * Create field from explicit type specification
+ */
+function createFieldFromExplicit(name, typeInfo) {
+    const { type, modifiers } = typeInfo;
+    // Check if it's an enum
+    if (type.startsWith('enum:')) {
+        const values = type.slice(5).split(',').map(v => v.trim());
+        return createEnumField(name, values);
+    }
+    return createField(name, type, modifiers);
+}
+/**
+ * Normalize type name to Kappa primitive
+ */
+function normalizeTypeName(type) {
+    const normalized = type.toLowerCase();
+    const typeMap = {
+        'integer': 'int',
+        'number': 'int',
+        'decimal': 'float',
+        'double': 'float',
+        'boolean': 'bool',
+        'datetime': 'timestamp',
+        'text': 'markdown',
+        'varchar': 'string',
+        'char': 'string',
+    };
+    return typeMap[normalized] || normalized;
+}
+/**
+ * Smart split that respects parentheses
+ */
+function smartSplit(str, delimiter) {
+    const result = [];
+    let current = '';
+    let depth = 0;
+    for (const char of str) {
+        if (char === '(')
+            depth++;
+        if (char === ')')
+            depth--;
+        if (char === delimiter && depth === 0) {
+            result.push(current);
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current)
+        result.push(current);
+    return result;
+}
+// =============================================================================
+// Page Parsing (Natural Language → PageBlock)
+// =============================================================================
+/**
+ * Parse natural language page descriptions into PageBlock AST
+ *
+ * Examples:
+ *   "Dashboard page at /dashboard"
+ *   "User profile at /users/:id with auth guard"
+ *   "Login page at /login for guests only"
+ */
+export function parsePageDescription(description) {
+    const pages = [];
+    // Try to parse as a single page description first
+    const page = parsePageBlock(description.trim());
+    if (page) {
+        pages.push(page);
+    }
+    return pages;
+}
+function parsePageBlock(block) {
+    // Extract page name and route
+    // Pattern: "PageName page at /route"
+    const routeMatch = block.match(/^([A-Z][a-zA-Z]*)\s+page\s+at\s+(\/[\w/:]*)/i);
+    if (!routeMatch) {
+        return null;
+    }
+    const pageName = routeMatch[1];
+    const route = routeMatch[2];
+    // Extract guard (authenticated, guest_only, admin, etc.)
+    let guard;
+    if (/with\s+auth(?:\s+guard)?|authenticated|requires?\s+auth/i.test(block)) {
+        guard = 'authenticated';
+    }
+    else if (/for\s+guests?(?:\s+only)?|guest[_\s]only/i.test(block)) {
+        guard = 'guest_only';
+    }
+    else if (/admin\s+only|requires?\s+admin/i.test(block)) {
+        guard = 'admin';
+    }
+    // Extract title
+    const titleMatch = block.match(/title[:\s]+["']([^"']+)["']/i);
+    const title = titleMatch ? titleMatch[1] : pageName;
+    // Extract loaders from "loads Entity data" or "loads Entity"
+    const loaders = [];
+    const loadsPattern = /loads?\s+([A-Z][a-zA-Z]*)\s*(?:data)?/gi;
+    const loadsMatches = [...block.matchAll(loadsPattern)];
+    for (const match of loadsMatches) {
+        const entityName = match[1];
+        const loaderName = entityName.toLowerCase();
+        // Determine source based on route parameters
+        let source;
+        if (route.includes(':id')) {
+            source = `api.get_${loaderName}($params.id)`;
+        }
+        else if (route.includes(`:${loaderName}Id`)) {
+            source = `api.get_${loaderName}($params.${loaderName}Id)`;
+        }
+        else {
+            // Default to list
+            source = `api.list_${loaderName}s`;
+        }
+        loaders.push({
+            kind: 'PageLoader',
+            name: loaderName,
+            source,
+            loc: { startLine: 1, startColumn: 1, endLine: 1, endColumn: 1, startOffset: 0, endOffset: 0 },
+        });
+    }
+    const actions = [];
+    return {
+        kind: 'PageBlock',
+        name: pageName,
+        route,
+        guard,
+        loaders,
+        actions,
+        title,
+        loc: { startLine: 1, startColumn: 1, endLine: 1, endColumn: 1, startOffset: 0, endOffset: 0 },
+    };
+}
+/**
+ * UI component keywords for detection
+ */
+const UI_COMPONENT_KEYWORDS = [
+    'button', 'input', 'card', 'modal', 'dialog', 'form', 'table',
+    'dropdown', 'select', 'checkbox', 'radio', 'switch', 'slider',
+    'tabs', 'accordion', 'tooltip', 'popover', 'menu', 'navbar',
+    'sidebar', 'footer', 'header', 'badge', 'chip', 'avatar',
+    'alert', 'notification', 'toast', 'skeleton', 'spinner', 'loader',
+    'progress', 'pagination', 'breadcrumb', 'stepper', 'calendar',
+    'datepicker', 'timepicker', 'textarea', 'search', 'combobox'
+];
+/**
+ * Detect if a name represents a UI component
+ */
+function isUIComponent(name) {
+    const lowerName = name.toLowerCase();
+    return UI_COMPONENT_KEYWORDS.some(keyword => lowerName.includes(keyword));
+}
+/**
+ * Parse component description into ComponentBlock
+ *
+ * Examples:
+ *   "Button with label, onClick, variant (primary/secondary)"
+ *   "Card with title, content, footer, variant (default/outlined/elevated)"
+ *   "Input with value, onChange, placeholder, disabled"
+ */
+export function parseComponentDescription(description) {
+    const errors = [];
+    const components = [];
+    // Split by component boundaries
+    const componentBlocks = splitIntoComponents(description);
+    for (const block of componentBlocks) {
+        try {
+            const component = parseComponentBlock(block);
+            components.push(component);
+        }
+        catch (e) {
+            errors.push(e instanceof Error ? e.message : String(e));
+        }
+    }
+    return {
+        success: errors.length === 0 && components.length > 0,
+        components,
+        errors,
+    };
+}
+/**
+ * Split description into component blocks
+ */
+function splitIntoComponents(description) {
+    // Pattern: ComponentName with/has ...
+    const pattern = /([A-Z][a-zA-Z]*)\s+(?:with|has|having)\s+/gi;
+    const matches = [...description.matchAll(pattern)];
+    if (matches.length === 0) {
+        // Try simpler pattern
+        const simpleMatch = description.match(/^([A-Z][a-zA-Z]*)\s*[:\-]?\s*(.+)$/);
+        if (simpleMatch) {
+            return [description];
+        }
+        return [];
+    }
+    const blocks = [];
+    for (let i = 0; i < matches.length; i++) {
+        const start = matches[i].index;
+        const end = i < matches.length - 1 ? matches[i + 1].index : description.length;
+        blocks.push(description.slice(start, end).trim());
+    }
+    return blocks;
+}
+/**
+ * Parse a single component block
+ */
+function parseComponentBlock(block) {
+    // Extract component name
+    const nameMatch = block.match(/^([A-Z][a-zA-Z]*)/);
+    if (!nameMatch) {
+        throw new Error(`Could not find component name in: ${block}`);
+    }
+    const componentName = nameMatch[1];
+    // Verify it's a UI component
+    if (!isUIComponent(componentName)) {
+        throw new Error(`"${componentName}" does not appear to be a UI component. Use entity parser for data models.`);
+    }
+    // Extract props part (after "with" or "has" or ":")
+    const propsMatch = block.match(/(?:with|has|having|:)\s*(.+)$/i);
+    if (!propsMatch) {
+        throw new Error(`Could not find props in: ${block}`);
+    }
+    const propsStr = propsMatch[1];
+    const { props, variants } = parseComponentPropsList(propsStr);
+    return {
+        kind: 'ComponentBlock',
+        name: componentName,
+        props,
+        variants,
+        loc: { startLine: 1, startColumn: 1, endLine: 1, endColumn: 1, startOffset: 0, endOffset: 0 },
+    };
+}
+/**
+ * Parse comma-separated props list
+ */
+function parseComponentPropsList(propsStr) {
+    const props = [];
+    const variants = [];
+    // Split by comma, but not inside parentheses
+    const parts = smartSplit(propsStr, ',');
+    for (const part of parts) {
+        const trimmed = part.trim();
+        if (!trimmed)
+            continue;
+        // Check for variant notation: "variant (primary/secondary/tertiary)"
+        const variantMatch = trimmed.match(/^variant\s*\(([^)]+)\)$/i);
+        if (variantMatch) {
+            const variantNames = variantMatch[1]
+                .split('/')
+                .map(v => v.trim())
+                .filter(v => v.length > 0);
+            for (const variantName of variantNames) {
+                variants.push({
+                    kind: 'ComponentVariant',
+                    name: variantName,
+                    modifications: [],
+                    loc: { startLine: 1, startColumn: 1, endLine: 1, endColumn: 1, startOffset: 0, endOffset: 0 },
+                });
+            }
+            continue;
+        }
+        // Check for enum notation: "size (sm/md/lg)"
+        const enumMatch = parseInlineEnum(trimmed);
+        if (enumMatch) {
+            // For components, enums become union type props
+            const unionType = enumMatch.values.map(v => `'${v}'`).join(' | ');
+            props.push(createComponentProp(enumMatch.name, unionType, false));
+            continue;
+        }
+        // Check for explicit type: "onClick:function" or "disabled:boolean"
+        const explicit = parseExplicitType(trimmed);
+        if (explicit) {
+            const optional = explicit.type.modifiers.includes('optional');
+            const propType = inferComponentPropType(explicit.name, explicit.type.type);
+            props.push(createComponentProp(explicit.name, propType, optional));
+            continue;
+        }
+        // Infer from prop name
+        const propName = trimmed.replace(/[^a-zA-Z0-9]/g, '');
+        if (propName) {
+            const propType = inferComponentPropType(propName);
+            const optional = isOptionalProp(propName);
+            props.push(createComponentProp(propName, propType, optional));
+        }
+    }
+    return { props, variants };
+}
+/**
+ * Create a component prop
+ */
+function createComponentProp(name, type, optional) {
+    return {
+        kind: 'ComponentProp',
+        name,
+        type,
+        optional,
+        loc: { startLine: 1, startColumn: 1, endLine: 1, endColumn: 1, startOffset: 0, endOffset: 0 },
+    };
+}
+/**
+ * Infer component prop type from name
+ */
+function inferComponentPropType(name, explicitType) {
+    if (explicitType) {
+        const typeMap = {
+            'string': 'string',
+            'int': 'number',
+            'integer': 'number',
+            'float': 'number',
+            'number': 'number',
+            'bool': 'boolean',
+            'boolean': 'boolean',
+            'function': '() => void',
+            'callback': '() => void',
+        };
+        return typeMap[explicitType.toLowerCase()] || explicitType;
+    }
+    const lowerName = name.toLowerCase();
+    // Event handlers
+    if (lowerName.startsWith('on')) {
+        return '() => void';
+    }
+    // Boolean flags
+    if (lowerName.startsWith('is') || lowerName.startsWith('has') || lowerName.startsWith('show') ||
+        ['disabled', 'readonly', 'required', 'loading', 'active', 'open', 'checked'].includes(lowerName)) {
+        return 'boolean';
+    }
+    // Children/content
+    if (['children', 'content', 'body'].includes(lowerName)) {
+        return 'React.ReactNode';
+    }
+    // Style/className
+    if (['classname', 'style'].includes(lowerName)) {
+        return lowerName === 'classname' ? 'string' : 'React.CSSProperties';
+    }
+    // Numeric values
+    if (['value', 'count', 'max', 'min', 'step', 'width', 'height'].includes(lowerName)) {
+        return 'number';
+    }
+    // Default to string
+    return 'string';
+}
+/**
+ * Determine if prop is optional based on common patterns
+ */
+function isOptionalProp(name) {
+    const lowerName = name.toLowerCase();
+    // Required props
+    const requiredProps = ['children', 'value', 'onchange', 'onclick', 'label', 'title'];
+    if (requiredProps.includes(lowerName)) {
+        return false;
+    }
+    // Optional props
+    const optionalProps = ['placeholder', 'disabled', 'readonly', 'className', 'style',
+        'variant', 'size', 'icon', 'tooltip', 'ariaLabel'];
+    if (optionalProps.includes(lowerName)) {
+        return true;
+    }
+    // Event handlers are usually optional except onChange/onClick
+    if (lowerName.startsWith('on') && !['onchange', 'onclick'].includes(lowerName)) {
+        return true;
+    }
+    // Default to optional
+    return true;
+}
+// =============================================================================
+// Form Parsing (Natural Language → FormBlock)
+// =============================================================================
+/**
+ * Parse natural language form description into FormBlock
+ *
+ * Examples:
+ *   "Login form with email, password, submit to /auth/login"
+ *   "Create Project form with name, description, submit to /api/projects"
+ *   "Contact form with name, email, message:textarea, submit to /contact"
+ */
+export function parseFormDescription(description) {
+    // Check if this is a form description
+    const formPattern = /^([A-Z][a-zA-Z\s]*?)\s+form\s+with\s+(.+?)(?:,\s*submit\s+to\s+([^\s,]+))?\s*$/i;
+    const match = description.match(formPattern);
+    if (!match) {
+        return null;
+    }
+    const [, formName, fieldsStr, submitEndpoint] = match;
+    // Parse fields
+    const fieldParts = smartSplit(fieldsStr, ',').map(s => s.trim()).filter(Boolean);
+    const fields = [];
+    for (const fieldPart of fieldParts) {
+        // Skip if this is the submit directive
+        if (fieldPart.toLowerCase().startsWith('submit to')) {
+            continue;
+        }
+        const field = parseFormField(fieldPart);
+        if (field) {
+            fields.push(field);
+        }
+    }
+    // Create submit action
+    const submit = {
+        kind: 'FormSubmit',
+        action: submitEndpoint || '/submit',
+        button: 'Submit',
+        onSuccess: 'redirect',
+        onError: 'show_error',
+        loc: createSourceLocation(),
+    };
+    // Create simple single-column layout
+    const layout = fields.map(field => ({
+        kind: 'FormLayoutRow',
+        fields: [field.name],
+        columns: 1,
+        loc: createSourceLocation(),
+    }));
+    return {
+        kind: 'FormBlock',
+        name: formName.trim().replace(/\s+/g, ''),
+        fields,
+        submit,
+        layout,
+        loc: createSourceLocation(),
+    };
+}
+/**
+ * Parse a single form field from natural language
+ * Examples:
+ *   "email" -> email field with email validation
+ *   "password" -> password field
+ *   "message:textarea" -> textarea field
+ *   "role:select(admin,user)" -> select field with options
+ */
+function parseFormField(fieldStr) {
+    // Check for explicit type: "fieldname:type"
+    const typeMatch = fieldStr.match(/^(\w+):(\w+)(?:\(([^)]+)\))?$/);
+    let name;
+    let type;
+    let options;
+    if (typeMatch) {
+        name = typeMatch[1];
+        const explicitType = typeMatch[2].toLowerCase();
+        const optionsStr = typeMatch[3];
+        // Map explicit types to form field types
+        type = mapToFormFieldType(explicitType);
+        // Parse options if present
+        if (optionsStr) {
+            options = optionsStr.split(',').map(s => s.trim());
+        }
+    }
+    else {
+        // Infer from field name
+        name = fieldStr.trim();
+        type = inferFormFieldType(name);
+    }
+    const label = capitalizeWords(name);
+    const required = !name.toLowerCase().includes('optional');
+    const field = {
+        kind: 'FormField',
+        name,
+        type,
+        label,
+        required,
+        loc: createSourceLocation(),
+    };
+    // Add options for select/multiselect
+    if (options && (type === 'select' || type === 'multiselect' || type === 'radio')) {
+        field.options = options.map(value => ({
+            kind: 'FormFieldOption',
+            value,
+            label: capitalizeWords(value),
+            loc: createSourceLocation(),
+        }));
+    }
+    // Add placeholder for text fields
+    if (['text', 'email', 'password', 'textarea'].includes(type)) {
+        field.placeholder = 'Enter ' + label.toLowerCase();
+    }
+    return field;
+}
+/**
+ * Map explicit type string to FormFieldType
+ */
+function mapToFormFieldType(typeStr) {
+    const typeMap = {
+        'text': 'text',
+        'textarea': 'textarea',
+        'email': 'email',
+        'password': 'password',
+        'number': 'number',
+        'select': 'select',
+        'multiselect': 'multiselect',
+        'checkbox': 'checkbox',
+        'radio': 'radio',
+        'date': 'date',
+        'time': 'time',
+        'datetime': 'datetime',
+        'file': 'file',
+    };
+    return typeMap[typeStr] || 'text';
+}
+/**
+ * Infer form field type from field name
+ */
+function inferFormFieldType(name) {
+    const lowerName = name.toLowerCase();
+    if (lowerName.includes('email'))
+        return 'email';
+    if (lowerName.includes('password'))
+        return 'password';
+    if (lowerName.includes('phone') || lowerName.includes('tel'))
+        return 'text';
+    if (lowerName.includes('message') || lowerName.includes('description') || lowerName.includes('bio'))
+        return 'textarea';
+    if (lowerName.includes('date') && lowerName.includes('time'))
+        return 'datetime';
+    if (lowerName.includes('date'))
+        return 'date';
+    if (lowerName.includes('time'))
+        return 'time';
+    if (lowerName.includes('age') || lowerName.includes('count') || lowerName.includes('number'))
+        return 'number';
+    if (lowerName.includes('agree') || lowerName.includes('accept') || lowerName.includes('confirm'))
+        return 'checkbox';
+    if (lowerName.includes('file') || lowerName.includes('upload') || lowerName.includes('attachment'))
+        return 'file';
+    return 'text';
+}
+/**
+ * Capitalize words in a string
+ */
+function capitalizeWords(str) {
+    return str
+        .replace(/([A-Z])/g, ' $1') // Add space before caps
+        .trim()
+        .split(/\s+/)
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join(' ');
+}
+/**
+ * Create a default source location
+ */
+function createSourceLocation() {
+    return {
+        startLine: 1,
+        startColumn: 1,
+        endLine: 1,
+        endColumn: 1,
+        startOffset: 0,
+        endOffset: 0,
+    };
+}