fastmode-mcp 1.0.0

package/dist/tools/validate-manifest.js

@@ -0,0 +1,311 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateManifest = validateManifest;
+const zod_1 = require("zod");
+const pageSchema = zod_1.z.object({
+    path: zod_1.z.string().startsWith('/'),
+    file: zod_1.z.string(),
+    title: zod_1.z.string(),
+    editable: zod_1.z.boolean().optional(),
+});
+// CMS templates use flat format: {slug}Index, {slug}Detail, {slug}IndexPath, {slug}DetailPath
+// This schema allows any string keys for collection templates
+const cmsTemplatesSchema = zod_1.z.record(zod_1.z.string()).optional();
+const manifestSchema = zod_1.z.object({
+    pages: zod_1.z.array(pageSchema),
+    cmsTemplates: cmsTemplatesSchema,
+    defaultHeadHtml: zod_1.z.string().optional(),
+});
+/**
+ * Validates a manifest.json file and returns errors or success message
+ */
+async function validateManifest(manifestJson) {
+    const errors = [];
+    const warnings = [];
+    // Try to parse JSON
+    let manifest;
+    try {
+        manifest = JSON.parse(manifestJson);
+    }
+    catch (e) {
+        const errorMessage = e instanceof Error ? e.message : 'Failed to parse JSON';
+        // Provide more specific diagnostics for common JSON errors
+        let diagnostics = '';
+        const trimmed = manifestJson.trim();
+        // Check for missing closing brace
+        if (!trimmed.endsWith('}')) {
+            diagnostics = `
+Detected Issue: File does not end with a closing brace '}'
+   The manifest.json appears to be truncated or missing the final '}'.
+   
+   Fix: Add a closing '}' at the end of the file.`;
+        }
+        // Check for missing opening brace
+        else if (!trimmed.startsWith('{')) {
+            diagnostics = `
+Detected Issue: File does not start with an opening brace '{'
+   The manifest.json must be a JSON object starting with '{'.`;
+        }
+        // Check bracket balance
+        else {
+            const openBraces = (manifestJson.match(/{/g) || []).length;
+            const closeBraces = (manifestJson.match(/}/g) || []).length;
+            const openBrackets = (manifestJson.match(/\[/g) || []).length;
+            const closeBrackets = (manifestJson.match(/]/g) || []).length;
+            if (openBraces !== closeBraces) {
+                diagnostics = `
+Detected Issue: Mismatched braces
+   Found ${openBraces} opening '{' but ${closeBraces} closing '}'
+   ${openBraces > closeBraces ? `Missing ${openBraces - closeBraces} closing brace(s) '}'` : `Extra ${closeBraces - openBraces} closing brace(s) '}'`}`;
+            }
+            else if (openBrackets !== closeBrackets) {
+                diagnostics = `
+Detected Issue: Mismatched brackets  
+   Found ${openBrackets} opening '[' but ${closeBrackets} closing ']'
+   ${openBrackets > closeBrackets ? `Missing ${openBrackets - closeBrackets} closing bracket(s) ']'` : `Extra ${closeBrackets - openBrackets} closing bracket(s) ']'`}`;
+            }
+            else {
+                // Generic guidance
+                diagnostics = `
+Common JSON issues to check:
+   - Missing or extra commas between items
+   - Trailing comma after last item in arrays/objects
+   - Unquoted property names (must use "key" not key)
+   - Single quotes instead of double quotes
+   - Unescaped special characters in strings`;
+            }
+        }
+        return `INVALID JSON
+
+Error: ${errorMessage}
+${diagnostics}
+
+Tip: Use a JSON validator (like jsonlint.com) to find the exact error location.`;
+    }
+    // Validate against schema
+    const result = manifestSchema.safeParse(manifest);
+    if (!result.success) {
+        for (const issue of result.error.issues) {
+            errors.push(`- ${issue.path.join('.')}: ${issue.message}`);
+        }
+    }
+    // Additional validation
+    const m = manifest;
+    // CRITICAL: Detect wrong "collections:" format (common AI mistake)
+    // AIs often use the wrong nested format instead of the flat cmsTemplates format
+    if (m.collections && !m.cmsTemplates) {
+        errors.push(`WRONG FORMAT: Use "cmsTemplates", not "collections"
+
+This is a common mistake. The correct format is:
+
+WRONG (what you have):
+"collections": {
+  "posts": { "indexPath": "/blog", "indexFile": "...", "detailPath": "...", "detailFile": "..." }
+}
+
+CORRECT (what you need):
+"cmsTemplates": {
+  "postsIndex": "templates/posts_index.html",
+  "postsDetail": "templates/posts_detail.html",
+  "postsIndexPath": "/blog",
+  "postsDetailPath": "/blog"
+}
+
+Note the flat structure with {slug}Index, {slug}Detail, {slug}IndexPath, {slug}DetailPath keys.`);
+    }
+    // Detect if cmsTemplates uses wrong nested format
+    if (m.cmsTemplates && typeof m.cmsTemplates === 'object') {
+        const templates = m.cmsTemplates;
+        for (const [key, value] of Object.entries(templates)) {
+            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                const nested = value;
+                if (nested.indexPath || nested.detailPath || nested.indexFile || nested.detailFile) {
+                    errors.push(`WRONG FORMAT in cmsTemplates.${key}: Using nested object format
+
+WRONG (what you have):
+"cmsTemplates": {
+  "${key}": { "indexPath": "...", "indexFile": "...", "detailPath": "...", "detailFile": "..." }
+}
+
+CORRECT (what you need):
+"cmsTemplates": {
+  "${key}Index": "templates/${key}_index.html",
+  "${key}Detail": "templates/${key}_detail.html",
+  "${key}IndexPath": "${nested.indexPath || '/' + key}",
+  "${key}DetailPath": "${nested.detailPath || '/' + key}"
+}
+
+Use the FLAT format with separate keys for each property.`);
+                    break; // Only show this error once
+                }
+            }
+        }
+    }
+    // Check pages array
+    if (!Array.isArray(m.pages)) {
+        errors.push('- pages: Must be an array');
+    }
+    else if (m.pages.length === 0) {
+        errors.push(`NO PAGES DEFINED: The pages array is empty.
+
+You must define at least one page, typically the homepage:
+
+"pages": [
+  { "path": "/", "file": "pages/index.html", "title": "Home" }
+]
+
+A site without pages will have no accessible content.`);
+    }
+    else {
+        // Check for homepage
+        const hasHomepage = m.pages.some((p) => p.path === '/');
+        if (!hasHomepage) {
+            errors.push(`NO HOMEPAGE: Missing path "/" in pages array.
+
+Every site needs a homepage. Add a page with path "/":
+
+"pages": [
+  { "path": "/", "file": "pages/index.html", "title": "Home" },
+  ...your other pages...
+]
+
+Without a homepage, visitors will see a 404 error.`);
+        }
+        // Check file paths
+        for (const page of m.pages) {
+            if (typeof page.file === 'string') {
+                if (!page.file.startsWith('pages/')) {
+                    warnings.push(`- Page "${page.path}": file should be in pages/ folder (got: ${page.file})`);
+                }
+                if (!page.file.endsWith('.html')) {
+                    warnings.push(`- Page "${page.path}": file should end with .html (got: ${page.file})`);
+                }
+            }
+        }
+    }
+    // Check cmsTemplates - enforce strict pattern-based validation
+    const templates = m.cmsTemplates;
+    const customCollections = new Set();
+    if (templates) {
+        // All keys must match the unified format: {slug}Index, {slug}Detail, {slug}IndexPath, {slug}DetailPath
+        const VALID_KEY_PATTERN = /^[a-z][a-zA-Z0-9_]*(Index|Detail|IndexPath|DetailPath)$/;
+        const KEY_PARTS_PATTERN = /^([a-z][a-zA-Z0-9_]*)(Index|Detail|IndexPath|DetailPath)$/;
+        for (const key of Object.keys(templates)) {
+            if (!VALID_KEY_PATTERN.test(key)) {
+                // Provide helpful error message with suggestion
+                let suggestion = '';
+                if (key.toLowerCase().includes('post')) {
+                    suggestion = ` Did you mean "${key.replace(/[Pp]ost/g, 'Detail')}"?`;
+                }
+                else if (!key.includes('Index') && !key.includes('Detail')) {
+                    suggestion = ` Did you mean "${key}Index" or "${key}Detail"?`;
+                }
+                errors.push(`- Invalid cmsTemplates key "${key}". ` +
+                    `All keys must use format: {slug}Index, {slug}Detail, {slug}IndexPath, or {slug}DetailPath.${suggestion}`);
+                continue;
+            }
+            // Extract collection slug from valid keys
+            const match = key.match(KEY_PARTS_PATTERN);
+            if (match) {
+                customCollections.add(match[1]);
+            }
+        }
+        // Validate each detected collection
+        for (const slug of customCollections) {
+            const indexTemplate = templates[`${slug}Index`];
+            const detailTemplate = templates[`${slug}Detail`];
+            const indexPath = templates[`${slug}IndexPath`];
+            const detailPath = templates[`${slug}DetailPath`];
+            // Check template file paths
+            if (typeof indexTemplate === 'string') {
+                if (!indexTemplate.endsWith('.html')) {
+                    warnings.push(`- cmsTemplates.${slug}Index: should end with .html (got: ${indexTemplate})`);
+                }
+            }
+            if (typeof detailTemplate === 'string') {
+                if (!detailTemplate.endsWith('.html')) {
+                    warnings.push(`- cmsTemplates.${slug}Detail: should end with .html (got: ${detailTemplate})`);
+                }
+            }
+            // Check path format
+            if (typeof indexPath === 'string' && !indexPath.startsWith('/')) {
+                errors.push(`- cmsTemplates.${slug}IndexPath: must start with "/" (got: ${indexPath})`);
+            }
+            if (typeof detailPath === 'string' && !detailPath.startsWith('/')) {
+                errors.push(`- cmsTemplates.${slug}DetailPath: must start with "/" (got: ${detailPath})`);
+            }
+            // Check consistency - incomplete CMS config will cause broken routes
+            if (indexTemplate && !detailTemplate) {
+                errors.push(`INCOMPLETE CMS CONFIG: Collection "${slug}" has ${slug}Index but no ${slug}Detail.
+
+Both templates are required for a collection to work:
+"cmsTemplates": {
+  "${slug}Index": "templates/${slug}_index.html",
+  "${slug}Detail": "templates/${slug}_detail.html",  // <- MISSING
+  "${slug}IndexPath": "${indexPath || '/' + slug}",
+  "${slug}DetailPath": "${detailPath || '/' + slug}"
+}
+
+Without both templates, clicking on list items will lead to 404 errors.`);
+            }
+            if (detailTemplate && !indexTemplate) {
+                errors.push(`INCOMPLETE CMS CONFIG: Collection "${slug}" has ${slug}Detail but no ${slug}Index.
+
+Both templates are required for a collection to work:
+"cmsTemplates": {
+  "${slug}Index": "templates/${slug}_index.html",  // <- MISSING
+  "${slug}Detail": "templates/${slug}_detail.html",
+  "${slug}IndexPath": "${indexPath || '/' + slug}",
+  "${slug}DetailPath": "${detailPath || '/' + slug}"
+}
+
+Without an index template, there's no way to list and navigate to items.`);
+            }
+            if (indexTemplate && !indexPath) {
+                warnings.push(`- Collection "${slug}": has ${slug}Index but no ${slug}IndexPath - using default path`);
+            }
+            if (detailTemplate && !detailPath) {
+                warnings.push(`- Collection "${slug}": has ${slug}Detail but no ${slug}DetailPath - using default path`);
+            }
+        }
+    }
+    // Build result
+    let output = '';
+    // Build collections summary
+    const collectionsSummary = customCollections.size > 0
+        ? `\n- Collections: ${Array.from(customCollections).join(', ')}`
+        : '';
+    if (errors.length === 0 && warnings.length === 0) {
+        output = `MANIFEST VALID
+
+The manifest.json structure is correct.
+
+Summary:
+- ${m.pages?.length || 0} static page(s) defined
+- CMS templates: ${templates ? 'configured in manifest' : 'not configured (can be set via Settings → CMS Templates after upload)'}${collectionsSummary}
+- Head HTML: ${m.defaultHeadHtml ? 'configured' : 'not configured'}`;
+    }
+    else if (errors.length === 0) {
+        output = `MANIFEST VALID WITH WARNINGS
+
+The manifest structure is valid but has potential issues:
+
+Warnings:
+${warnings.join('\n')}
+
+Tip: CMS templates can also be configured after upload via Dashboard → Settings → CMS Templates`;
+    }
+    else {
+        output = `MANIFEST INVALID
+
+Errors (must fix):
+${errors.join('\n')}`;
+        if (warnings.length > 0) {
+            output += `
+
+Warnings:
+${warnings.join('\n')}`;
+        }
+    }
+    return output;
+}

package/dist/tools/validate-package.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Validates the complete structure of a CMS website package
+ */
+export declare function validatePackage(fileList: string[], manifestContent: string, templateContents?: Record<string, string>): Promise<string>;
+//# sourceMappingURL=validate-package.d.ts.map

package/dist/tools/validate-package.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-package.d.ts","sourceRoot":"","sources":["../../src/tools/validate-package.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,MAAM,EAAE,EAClB,eAAe,EAAE,MAAM,EACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACxC,OAAO,CAAC,MAAM,CAAC,CA4VjB"}

package/dist/tools/validate-package.js

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePackage = validatePackage;
+const validate_manifest_1 = require("./validate-manifest");
+const validate_template_1 = require("./validate-template");
+/**
+ * Validates the complete structure of a CMS website package
+ */
+async function validatePackage(fileList, manifestContent, templateContents) {
+    const errors = [];
+    const warnings = [];
+    const validations = [];
+    // 1. Check required structure
+    const hasManifest = fileList.some(f => f === 'manifest.json' || f.endsWith('/manifest.json'));
+    const hasPagesFolder = fileList.some(f => f.includes('pages/'));
+    const hasPublicFolder = fileList.some(f => f.includes('public/'));
+    if (!hasManifest) {
+        errors.push('- Missing manifest.json at package root');
+    }
+    else {
+        validations.push('manifest.json found');
+    }
+    if (!hasPagesFolder) {
+        warnings.push('- No pages/ folder found - static pages should be in pages/');
+    }
+    else {
+        validations.push('pages/ folder found');
+    }
+    if (!hasPublicFolder) {
+        warnings.push('- No public/ folder found - assets (CSS, JS, images) should be in public/');
+    }
+    else {
+        validations.push('public/ folder found');
+    }
+    // 1b. Check for WRONG folder structures (common AI mistakes)
+    const hasAssetsFolder = fileList.some(f => f.includes('assets/') && !f.includes('public/assets/'));
+    const hasCollectionsFolder = fileList.some(f => f.includes('collections/') && f.endsWith('.html'));
+    const hasTemplatesFolder = fileList.some(f => f.includes('templates/'));
+    // Error: Using /assets/ instead of /public/
+    if (hasAssetsFolder && !hasPublicFolder) {
+        errors.push(`WRONG FOLDER: Using "assets/" instead of "public/"
+
+Fast Mode serves static assets from the /public/ folder, NOT /assets/.
+
+WRONG structure:
+assets/
+├── css/style.css    ← Won't be served!
+└── js/main.js       ← Won't be served!
+
+CORRECT structure:
+public/
+├── css/style.css    ← Served at /css/style.css
+└── js/main.js       ← Served at /js/main.js
+
+Move all files from assets/ to public/`);
+    }
+    else if (hasAssetsFolder) {
+        warnings.push(`- Found assets/ folder - assets should be in public/, not assets/`);
+    }
+    // Error: Using /collections/ instead of /templates/
+    if (hasCollectionsFolder) {
+        errors.push(`WRONG FOLDER: Using "collections/" instead of "templates/"
+
+CMS templates should be in the templates/ folder, NOT collections/.
+
+WRONG structure:
+collections/
+├── posts/
+│   ├── index.html   ← Wrong location!
+│   └── detail.html  ← Wrong location!
+
+CORRECT structure:
+templates/
+├── posts_index.html
+└── posts_detail.html
+
+Note: Template files use {collection}_index.html and {collection}_detail.html naming.`);
+    }
+    // Warning: No templates folder but has cmsTemplates in manifest (potential issue)
+    if (!hasTemplatesFolder && hasPagesFolder) {
+        // This is just a hint - might be fine if no CMS content
+        // We'll check more specifically later when validating manifest
+    }
+    // 2. Validate manifest
+    const manifestResult = await (0, validate_manifest_1.validateManifest)(manifestContent);
+    if (manifestResult.includes('INVALID')) {
+        errors.push('- Manifest validation failed (see details below)');
+    }
+    else if (manifestResult.includes('WARNINGS')) {
+        warnings.push('- Manifest has warnings (see details below)');
+    }
+    else {
+        validations.push('manifest.json is valid');
+    }
+    // 3. Parse manifest for template checks
+    let manifest = null;
+    try {
+        manifest = JSON.parse(manifestContent);
+    }
+    catch {
+        // Already caught in manifest validation
+    }
+    // 4. Check that referenced files exist
+    if (manifest?.pages && Array.isArray(manifest.pages)) {
+        for (const page of manifest.pages) {
+            const p = page;
+            if (typeof p.file === 'string') {
+                const fileExists = fileList.some(f => f === p.file || f.endsWith('/' + p.file));
+                if (!fileExists) {
+                    errors.push(`- Page file not found: ${p.file} (referenced by path ${p.path})`);
+                }
+            }
+        }
+    }
+    // 5. Check CMS template files exist (detect custom collections from manifest)
+    if (manifest?.cmsTemplates) {
+        const templates = manifest.cmsTemplates;
+        const checkedTemplates = new Set();
+        for (const [key, value] of Object.entries(templates)) {
+            // Skip path keys and non-string values
+            if (key.endsWith('Path') || typeof value !== 'string' || !value.endsWith('.html')) {
+                continue;
+            }
+            // Avoid duplicate checks
+            if (checkedTemplates.has(value))
+                continue;
+            checkedTemplates.add(value);
+            const fileExists = fileList.some(f => f === value || f.endsWith('/' + value));
+            if (!fileExists) {
+                errors.push(`- Template file not found: ${value} (cmsTemplates.${key})`);
+            }
+            else {
+                validations.push(`${key} template exists`);
+            }
+        }
+    }
+    // 6. Validate template contents if provided
+    const templateValidations = [];
+    if (templateContents) {
+        for (const [path, content] of Object.entries(templateContents)) {
+            // Determine template type based on path
+            let templateType = 'static_page';
+            // Check if it's an index template
+            if (path.includes('_index') || path.includes('-index')) {
+                templateType = 'custom_index';
+            }
+            // Check if it's a detail template
+            else if (path.includes('_detail') || path.includes('-detail') || path.includes('_post') || path.includes('-post')) {
+                templateType = 'custom_detail';
+            }
+            // Check if it's in templates/ folder (likely a CMS template)
+            else if (path.includes('templates/')) {
+                // If it has collection-like patterns
+                if (content.includes('{{#each')) {
+                    templateType = 'custom_index';
+                }
+                else if (content.includes('{{name}}') || content.includes('{{slug}}')) {
+                    templateType = 'custom_detail';
+                }
+            }
+            const result = await (0, validate_template_1.validateTemplate)(content, templateType);
+            if (result.includes('ERRORS')) {
+                errors.push(`- Template ${path} has errors`);
+                templateValidations.push(`\n### ${path}\n${result}`);
+            }
+            else if (result.includes('WARNINGS')) {
+                warnings.push(`- Template ${path} has warnings`);
+                templateValidations.push(`\n### ${path}\n${result}`);
+            }
+        }
+    }
+    // 7. Check template URL consistency with manifest paths
+    if (manifest?.cmsTemplates && templateContents) {
+        // Extract collection paths from manifest
+        const collectionPaths = {};
+        for (const [key, value] of Object.entries(manifest.cmsTemplates)) {
+            if (key.endsWith('IndexPath') && typeof value === 'string') {
+                const slug = key.replace('IndexPath', '');
+                if (!collectionPaths[slug])
+                    collectionPaths[slug] = {};
+                collectionPaths[slug].indexPath = value;
+            }
+            if (key.endsWith('DetailPath') && typeof value === 'string') {
+                const slug = key.replace('DetailPath', '');
+                if (!collectionPaths[slug])
+                    collectionPaths[slug] = {};
+                collectionPaths[slug].detailPath = value;
+            }
+        }
+        // Check templates for URL mismatches
+        for (const [templatePath, content] of Object.entries(templateContents)) {
+            // Look for hardcoded links that might not match manifest
+            const hrefMatches = content.match(/href=["']\/([^"'{}]+)\/\{\{/g);
+            if (hrefMatches) {
+                for (const match of hrefMatches) {
+                    // Extract the path like "/posts/" from href="/posts/{{slug}}"
+                    const pathMatch = match.match(/href=["']\/([^"'{}]+)\//);
+                    if (pathMatch) {
+                        const usedPath = '/' + pathMatch[1];
+                        // Check if this path exists in any of our defined collection paths
+                        let pathFound = false;
+                        for (const paths of Object.values(collectionPaths)) {
+                            if (paths.detailPath === usedPath || paths.indexPath === usedPath) {
+                                pathFound = true;
+                                break;
+                            }
+                        }
+                        if (!pathFound && Object.keys(collectionPaths).length > 0) {
+                            const availablePaths = Object.entries(collectionPaths)
+                                .map(([slug, p]) => `${slug}: ${p.indexPath || p.detailPath}`)
+                                .join(', ');
+                            warnings.push(`- Template ${templatePath}: Uses "${usedPath}" which doesn't match manifest paths (${availablePaths})`);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // 8. Check for common issues in file structure
+    const htmlFiles = fileList.filter(f => f.endsWith('.html'));
+    const cssFiles = fileList.filter(f => f.endsWith('.css'));
+    const jsFiles = fileList.filter(f => f.endsWith('.js'));
+    const imageFiles = fileList.filter(f => /\.(png|jpg|jpeg|gif|svg|webp|ico)$/i.test(f));
+    // Check CSS files are in public - these will 404 if not in public/
+    for (const css of cssFiles) {
+        if (!css.includes('public/')) {
+            const fileName = css.split('/').pop();
+            errors.push(`WRONG LOCATION: CSS file "${css}" must be in public/ folder.
+
+Move to: public/css/${fileName}
+Reference in HTML as: /css/${fileName}
+
+Files outside public/ will not be served and will cause 404 errors.`);
+        }
+    }
+    // Check JS files are in public - these will 404 if not in public/
+    for (const js of jsFiles) {
+        if (!js.includes('public/') && !js.includes('node_modules')) {
+            const fileName = js.split('/').pop();
+            errors.push(`WRONG LOCATION: JS file "${js}" must be in public/ folder.
+
+Move to: public/js/${fileName}
+Reference in HTML as: /js/${fileName}
+
+Files outside public/ will not be served and will cause 404 errors.`);
+        }
+    }
+    // Check images are in public - these will 404 if not in public/
+    for (const img of imageFiles) {
+        if (!img.includes('public/')) {
+            const fileName = img.split('/').pop();
+            errors.push(`WRONG LOCATION: Image file "${img}" must be in public/ folder.
+
+Move to: public/images/${fileName}
+Reference in HTML as: /images/${fileName}
+
+Files outside public/ will not be served and will cause 404 errors.`);
+        }
+    }
+    // 9. Check JS files for potential form handler conflicts
+    if (templateContents) {
+        for (const [path, content] of Object.entries(templateContents)) {
+            if (path.endsWith('.js')) {
+                // Check for form submit handlers that might block CMS form submission
+                const hasSubmitListener = content.includes('addEventListener') && content.includes('submit');
+                const hasPreventDefault = content.includes('preventDefault');
+                const hasFormsEndpoint = content.includes('/_forms/');
+                if (hasSubmitListener && hasPreventDefault && !hasFormsEndpoint) {
+                    warnings.push(`POTENTIAL FORM ISSUE: ${path} has form handlers with preventDefault() but no /_forms/ endpoint.
+
+This JavaScript may block form submissions from reaching Fast Mode!
+
+LOOK FOR patterns like:
+  form.addEventListener('submit', (e) => {
+    e.preventDefault();
+    showToast('Message sent!');  // FAKE - data not saved!
+  });
+
+FIX BY either:
+1. Remove the original handler entirely (use native form submission)
+2. Update handler to POST to /_forms/{formName}
+
+See get_conversion_guide(section: "forms") for proper form setup.`);
+                }
+            }
+        }
+    }
+    // Build result
+    let output = '';
+    if (errors.length === 0) {
+        output = `PACKAGE STRUCTURE VALID
+
+${validations.map(v => `- ${v}`).join('\n')}
+
+Summary:
+- ${htmlFiles.length} HTML file(s)
+- ${cssFiles.length} CSS file(s)
+- ${jsFiles.length} JS file(s)
+- ${imageFiles.length} image file(s)`;
+        if (warnings.length > 0) {
+            output += `
+
+Warnings (consider fixing):
+${warnings.join('\n')}`;
+        }
+    }
+    else {
+        output = `PACKAGE HAS ERRORS
+
+Errors (must fix):
+${errors.join('\n')}
+
+What passed:
+${validations.map(v => `- ${v}`).join('\n')}`;
+        if (warnings.length > 0) {
+            output += `
+
+Warnings:
+${warnings.join('\n')}`;
+        }
+    }
+    // Add manifest details
+    output += `
+
+---
+## Manifest Validation Details
+${manifestResult}`;
+    // Add template validation details
+    if (templateValidations.length > 0) {
+        output += `
+
+---
+## Template Validation Details
+${templateValidations.join('\n')}`;
+    }
+    return output;
+}

package/dist/tools/validate-template.d.ts

@@ -0,0 +1,12 @@
+type TemplateType = 'custom_index' | 'custom_detail' | 'static_page';
+/**
+ * Validates an HTML template for correct CMS token usage
+ *
+ * @param html - The HTML template content
+ * @param templateType - The type of template (custom_index, custom_detail, static_page)
+ * @param collectionSlug - For custom collections, the collection slug
+ * @param projectId - Optional: Project ID or name to validate against actual schema
+ */
+export declare function validateTemplate(html: string, templateType: TemplateType, collectionSlug?: string, projectId?: string): Promise<string>;
+export {};
+//# sourceMappingURL=validate-template.d.ts.map

package/dist/tools/validate-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-template.d.ts","sourceRoot":"","sources":["../../src/tools/validate-template.ts"],"names":[],"mappings":"AAMA,KAAK,YAAY,GAAG,cAAc,GAAG,eAAe,GAAG,aAAa,CAAC;AAmUrE;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,YAAY,EAC1B,cAAc,CAAC,EAAE,MAAM,EACvB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC,CA8kBjB"}