@brandsystem/mcp 0.3.0

package/dist/tools/brand-init.js

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import { BrandDir } from "../lib/brand-dir.js";
+import { buildResponse, safeParseParams } from "../lib/response.js";
+import { SCHEMA_VERSION } from "../schemas/index.js";
+import { ERROR_CODES } from "../types/index.js";
+const paramsShape = {
+    client_name: z.string().describe("Company or brand name"),
+    industry: z.string().optional().describe("Industry vertical (e.g. 'content marketing agency')"),
+    website_url: z.string().optional().describe("Primary website URL for web extraction"),
+    figma_file_key: z.string().optional().describe("Figma file key for design token extraction"),
+};
+const ParamsSchema = z.object(paramsShape);
+async function handler(input) {
+    const brandDir = new BrandDir(process.cwd());
+    if (await brandDir.exists()) {
+        return buildResponse({
+            what_happened: ".brand/ directory already exists",
+            next_steps: [
+                "Run brand_status to see current state",
+                "Delete .brand/ manually if you want to start over",
+            ],
+            data: { error: ERROR_CODES.ALREADY_EXISTS },
+        });
+    }
+    // Shared init logic (scaffold + config + empty core identity)
+    await brandDir.initBrand({
+        schema_version: SCHEMA_VERSION,
+        session: 1,
+        client_name: input.client_name,
+        industry: input.industry,
+        website_url: input.website_url,
+        figma_file_key: input.figma_file_key,
+        created_at: new Date().toISOString(),
+    });
+    const nextSteps = [];
+    if (input.website_url) {
+        nextSteps.push(`Run brand_extract_web with url "${input.website_url}" to pull colors, fonts, and logo`);
+    }
+    else {
+        nextSteps.push("Run brand_extract_web with your website URL to pull colors, fonts, and logo");
+    }
+    if (input.figma_file_key) {
+        nextSteps.push(`Run brand_extract_figma with figma_file_key "${input.figma_file_key}" to extract design tokens`);
+    }
+    else {
+        nextSteps.push("Run brand_extract_figma if you have a Figma file with brand tokens");
+    }
+    return buildResponse({
+        what_happened: `Created .brand/ directory for "${input.client_name}"`,
+        next_steps: nextSteps,
+        data: {
+            client_name: input.client_name,
+            brand_dir: ".brand/",
+            files_created: ["brand.config.yaml", "core-identity.yaml", "assets/logo/"],
+        },
+    });
+}
+export function register(server) {
+    server.tool("brand_init", "Initialize a .brand/ directory with empty config scaffold. Low-level tool — prefer brand_start instead, which calls this automatically and also presents extraction options. Only use brand_init directly if you need to set up the directory without running extraction. Returns list of created files.", paramsShape, async (args) => {
+        const parsed = safeParseParams(ParamsSchema, args);
+        if (!parsed.success)
+            return parsed.response;
+        return handler(parsed.data);
+    });
+}
+//# sourceMappingURL=brand-init.js.map

package/dist/tools/brand-init.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"brand-init.js","sourceRoot":"","sources":["../../src/tools/brand-init.ts"],"names":[],"mappings":"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"}

package/dist/tools/brand-preflight.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function register(server: McpServer): void;
+//# sourceMappingURL=brand-preflight.d.ts.map

package/dist/tools/brand-preflight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brand-preflight.d.ts","sourceRoot":"","sources":["../../src/tools/brand-preflight.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAosBzE,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,QAWzC"}

package/dist/tools/brand-preflight.js

@@ -0,0 +1,608 @@
+import { z } from "zod";
+import { BrandDir } from "../lib/brand-dir.js";
+import { buildResponse, safeParseParams } from "../lib/response.js";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import * as cheerio from "cheerio";
+import { ERROR_CODES } from "../types/index.js";
+// ---------------------------------------------------------------------------
+// Color utilities
+// ---------------------------------------------------------------------------
+/** Expand shorthand hex (#abc -> #aabbcc) and lowercase */
+function normalizeHex(hex) {
+    let h = hex.toLowerCase().trim();
+    if (/^#[0-9a-f]{3}$/.test(h)) {
+        h = `#${h[1]}${h[1]}${h[2]}${h[2]}${h[3]}${h[3]}`;
+    }
+    // Strip alpha channel from 8-digit hex for comparison
+    if (/^#[0-9a-f]{8}$/.test(h)) {
+        h = h.slice(0, 7);
+    }
+    return h;
+}
+/** Convert rgb/rgba to hex. Returns null if not parseable. */
+function rgbToHex(rgb) {
+    const match = rgb.match(/rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/);
+    if (!match)
+        return null;
+    const [, r, g, b] = match;
+    const toHex = (n) => parseInt(n, 10).toString(16).padStart(2, "0");
+    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+/** Extract all color values from CSS text, normalized to hex */
+function extractColors(css) {
+    const colors = [];
+    // Hex colors
+    const hexRe = /#[0-9a-fA-F]{3,8}\b/g;
+    let m;
+    while ((m = hexRe.exec(css)) !== null) {
+        colors.push(normalizeHex(m[0]));
+    }
+    // rgb/rgba
+    const rgbRe = /rgba?\(\s*\d+\s*,\s*\d+\s*,\s*\d+(?:\s*,\s*[\d.]+)?\s*\)/g;
+    while ((m = rgbRe.exec(css)) !== null) {
+        const hex = rgbToHex(m[0]);
+        if (hex)
+            colors.push(normalizeHex(hex));
+    }
+    return [...new Set(colors)];
+}
+/** Extract all font-family values from CSS text */
+function extractFontFamilies(css) {
+    const families = [];
+    const re = /font-family\s*:\s*([^;}"]+)/gi;
+    let m;
+    while ((m = re.exec(css)) !== null) {
+        const raw = m[1].trim();
+        // Split by comma and clean up
+        for (const part of raw.split(",")) {
+            const clean = part.trim().replace(/^['"]|['"]$/g, "").trim();
+            if (clean)
+                families.push(clean);
+        }
+    }
+    return [...new Set(families)];
+}
+const SYSTEM_FONT_FAMILIES = new Set([
+    "serif", "sans-serif", "monospace", "cursive", "fantasy", "system-ui",
+    "ui-serif", "ui-sans-serif", "ui-monospace", "ui-rounded",
+    "-apple-system", "blinkmacsystemfont", "segoe ui", "roboto",
+    "helvetica neue", "arial", "noto sans", "liberation sans",
+    "helvetica", "times new roman", "times", "georgia", "courier new",
+    "courier", "verdana", "tahoma", "trebuchet ms", "lucida grande",
+    "lucida sans unicode", "lucida console", "monaco", "menlo", "consolas",
+]);
+// ---------------------------------------------------------------------------
+// CSS extraction from HTML
+// ---------------------------------------------------------------------------
+function extractAllCss($) {
+    const parts = [];
+    // <style> blocks
+    $("style").each((_i, el) => {
+        const text = $(el).text();
+        if (text)
+            parts.push(text);
+    });
+    // style attributes
+    $("[style]").each((_i, el) => {
+        const style = $(el).attr("style");
+        if (style)
+            parts.push(style);
+    });
+    return parts.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Rules compilation
+// ---------------------------------------------------------------------------
+function compileRules(identity, antiPatterns) {
+    const rules = [];
+    // Color rules
+    rules.push({
+        id: "C-HEX",
+        description: "All hex colors in CSS must be in the brand palette",
+        severity: "soft",
+        source: "core-identity.yaml colors",
+        checkable: identity.colors.length > 0,
+    });
+    rules.push({
+        id: "C-PRIMARY",
+        description: "Primary brand color must appear somewhere in the content",
+        severity: "soft",
+        source: "core-identity.yaml colors[role=primary]",
+        checkable: identity.colors.some((c) => c.role === "primary"),
+    });
+    rules.push({
+        id: "C-PALETTE",
+        description: "No off-palette colors (all used colors should match brand palette)",
+        severity: "soft",
+        source: "core-identity.yaml colors",
+        checkable: identity.colors.length > 0,
+    });
+    // Typography rules
+    rules.push({
+        id: "T-FAMILY",
+        description: "All font-family declarations must reference known brand fonts",
+        severity: "soft",
+        source: "core-identity.yaml typography",
+        checkable: identity.typography.length > 0,
+    });
+    rules.push({
+        id: "T-SYSTEM",
+        description: "Brand fonts must be loaded (not only system fonts used as primary)",
+        severity: "soft",
+        source: "core-identity.yaml typography",
+        checkable: identity.typography.length > 0,
+    });
+    // Logo rules
+    rules.push({
+        id: "L-PRESENT",
+        description: "If brand name appears as text, logo SVG should also be present",
+        severity: "soft",
+        source: "core-identity.yaml logo + brand.config.yaml client_name",
+        checkable: true,
+    });
+    rules.push({
+        id: "L-APPROX",
+        description: "No logo approximation (brand name in styled span/div without actual SVG)",
+        severity: "soft",
+        source: "core-identity.yaml logo",
+        checkable: true,
+    });
+    // Anti-pattern rules from visual-identity.yaml
+    let apIndex = 1;
+    for (const ap of antiPatterns) {
+        const id = ap.preflight_id || `A-${apIndex}`;
+        apIndex++;
+        rules.push({
+            id,
+            description: ap.rule,
+            severity: ap.severity,
+            source: "visual-identity.yaml anti_patterns",
+            checkable: true,
+        });
+    }
+    return rules;
+}
+/** Map common anti-pattern phrases to CSS checks */
+const ANTI_PATTERN_MATCHERS = [
+    {
+        keywords: ["drop shadow", "drop-shadow", "box shadow", "box-shadow"],
+        test: (css) => /box-shadow\s*:/i.test(css) ||
+            /text-shadow\s*:/i.test(css) ||
+            /filter\s*:.*drop-shadow/i.test(css),
+    },
+    {
+        keywords: ["gradient"],
+        test: (css) => /(?:linear|radial|conic)-gradient/i.test(css),
+    },
+    {
+        keywords: ["border radius", "border-radius", "rounded corner", "rounded corners", "pill shape"],
+        test: (css) => /border-radius\s*:/i.test(css),
+    },
+    {
+        keywords: ["opacity"],
+        test: (css) => /\bopacity\s*:\s*(?!1\b|1\.0)/i.test(css),
+    },
+    {
+        keywords: ["blur"],
+        test: (css) => /filter\s*:.*blur/i.test(css) || /backdrop-filter\s*:.*blur/i.test(css),
+    },
+    {
+        keywords: ["animation", "animate", "transition"],
+        test: (css) => /animation\s*:/i.test(css) || /transition\s*:/i.test(css),
+    },
+    {
+        keywords: ["outline"],
+        test: (css) => /\boutline\s*:/i.test(css),
+    },
+    {
+        keywords: ["underline", "text-decoration"],
+        test: (css) => /text-decoration\s*:.*underline/i.test(css),
+    },
+    {
+        keywords: ["italic"],
+        test: (css) => /font-style\s*:\s*italic/i.test(css),
+    },
+    {
+        keywords: ["uppercase", "text-transform"],
+        test: (css) => /text-transform\s*:\s*uppercase/i.test(css),
+    },
+    {
+        keywords: ["centered body", "center body", "text-align: center", "centered text"],
+        test: (css) => /text-align\s*:\s*center/i.test(css),
+    },
+];
+function matchAntiPattern(rule, css) {
+    const lower = rule.toLowerCase();
+    for (const matcher of ANTI_PATTERN_MATCHERS) {
+        if (matcher.keywords.some((kw) => lower.includes(kw))) {
+            return matcher.test(css);
+        }
+    }
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Check runners
+// ---------------------------------------------------------------------------
+function checkColors(css, identity) {
+    const checks = [];
+    const brandColors = identity.colors.map((c) => normalizeHex(c.value));
+    const usedColors = extractColors(css);
+    if (identity.colors.length === 0) {
+        checks.push({
+            id: "C-HEX",
+            status: "warn",
+            message: "No brand colors defined — cannot check hex compliance",
+            details: "Add colors to core-identity.yaml first",
+        });
+        checks.push({
+            id: "C-PRIMARY",
+            status: "warn",
+            message: "No brand colors defined",
+        });
+        checks.push({
+            id: "C-PALETTE",
+            status: "warn",
+            message: "No brand palette to check against",
+        });
+        return checks;
+    }
+    // C-HEX: Check unknown colors
+    const unknownColors = usedColors.filter((c) => !brandColors.includes(c));
+    // Filter out common non-brand colors (pure black, white)
+    const meaningfulUnknown = unknownColors.filter((c) => !["#000000", "#ffffff"].includes(c));
+    if (meaningfulUnknown.length === 0) {
+        checks.push({
+            id: "C-HEX",
+            status: "pass",
+            message: `All ${usedColors.length} colors are on-palette`,
+        });
+    }
+    else {
+        checks.push({
+            id: "C-HEX",
+            status: "warn",
+            message: `${meaningfulUnknown.length} color(s) not in brand palette`,
+            details: meaningfulUnknown.slice(0, 10).join(", "),
+        });
+    }
+    // C-PRIMARY: Primary color used
+    const primaryColor = identity.colors.find((c) => c.role === "primary");
+    if (!primaryColor) {
+        checks.push({
+            id: "C-PRIMARY",
+            status: "warn",
+            message: "No primary color role assigned in brand identity",
+        });
+    }
+    else {
+        const pHex = normalizeHex(primaryColor.value);
+        if (usedColors.includes(pHex)) {
+            checks.push({
+                id: "C-PRIMARY",
+                status: "pass",
+                message: `Primary color ${pHex} is used`,
+            });
+        }
+        else {
+            checks.push({
+                id: "C-PRIMARY",
+                status: "warn",
+                message: `Primary color ${pHex} not found in content`,
+                details: `Brand primary is ${primaryColor.name} (${pHex})`,
+            });
+        }
+    }
+    // C-PALETTE: Off-palette summary
+    if (meaningfulUnknown.length === 0) {
+        checks.push({
+            id: "C-PALETTE",
+            status: "pass",
+            message: "No off-palette colors detected",
+        });
+    }
+    else {
+        checks.push({
+            id: "C-PALETTE",
+            status: "warn",
+            message: `${meaningfulUnknown.length} off-palette color(s) found`,
+            details: `Brand palette: ${brandColors.join(", ")} | Off-palette: ${meaningfulUnknown.slice(0, 5).join(", ")}${meaningfulUnknown.length > 5 ? ` (+${meaningfulUnknown.length - 5} more)` : ""}`,
+        });
+    }
+    return checks;
+}
+function checkTypography(css, identity) {
+    const checks = [];
+    const brandFonts = identity.typography.map((t) => t.family.toLowerCase());
+    const usedFamilies = extractFontFamilies(css).map((f) => f.toLowerCase());
+    if (identity.typography.length === 0) {
+        checks.push({
+            id: "T-FAMILY",
+            status: "warn",
+            message: "No brand fonts defined — cannot check typography compliance",
+        });
+        checks.push({
+            id: "T-SYSTEM",
+            status: "warn",
+            message: "No brand fonts defined",
+        });
+        return checks;
+    }
+    if (usedFamilies.length === 0) {
+        checks.push({
+            id: "T-FAMILY",
+            status: "warn",
+            message: "No font-family declarations found in content",
+        });
+        checks.push({
+            id: "T-SYSTEM",
+            status: "pass",
+            message: "No font declarations to check",
+        });
+        return checks;
+    }
+    // T-FAMILY: Check that declared fonts are brand fonts
+    const nonBrand = usedFamilies.filter((f) => !brandFonts.includes(f) && !SYSTEM_FONT_FAMILIES.has(f));
+    if (nonBrand.length === 0) {
+        checks.push({
+            id: "T-FAMILY",
+            status: "pass",
+            message: "All font-family declarations use brand fonts or system fallbacks",
+        });
+    }
+    else {
+        checks.push({
+            id: "T-FAMILY",
+            status: "warn",
+            message: `${nonBrand.length} non-brand font(s) detected`,
+            details: nonBrand.join(", "),
+        });
+    }
+    // T-SYSTEM: Check if ONLY system fonts are used (no brand fonts loaded)
+    const hasBrandFont = usedFamilies.some((f) => brandFonts.includes(f));
+    if (hasBrandFont) {
+        checks.push({
+            id: "T-SYSTEM",
+            status: "pass",
+            message: "Brand font(s) are loaded",
+        });
+    }
+    else {
+        checks.push({
+            id: "T-SYSTEM",
+            status: "warn",
+            message: "Only system fonts detected — brand fonts may not be loaded",
+            details: `Expected: ${identity.typography.map((t) => t.family).join(", ")} | Found: ${usedFamilies.join(", ")}`,
+        });
+    }
+    return checks;
+}
+function checkLogo($, identity, clientName) {
+    const checks = [];
+    const hasSvg = $("svg").length > 0;
+    const hasImgLogo = $("img[src*='logo'], img[alt*='logo']").length > 0;
+    const hasLogoElement = hasSvg || hasImgLogo;
+    // Check if brand name appears as text
+    const bodyText = $("body").text() || $.text();
+    const nameInText = clientName
+        ? bodyText.toLowerCase().includes(clientName.toLowerCase())
+        : false;
+    // L-PRESENT
+    if (!nameInText) {
+        checks.push({
+            id: "L-PRESENT",
+            status: "pass",
+            message: "Brand name not found as text (no logo check needed)",
+        });
+    }
+    else if (hasLogoElement) {
+        checks.push({
+            id: "L-PRESENT",
+            status: "pass",
+            message: "Brand name and logo element both present",
+        });
+    }
+    else {
+        checks.push({
+            id: "L-PRESENT",
+            status: "warn",
+            message: "Brand name appears as text but no logo SVG/image found",
+            details: `"${clientName}" found in text but no <svg> or logo <img> detected`,
+        });
+    }
+    // L-APPROX: Check for logo approximation patterns
+    let approxFound = false;
+    if (clientName) {
+        const nameLower = clientName.toLowerCase();
+        $("span, div, a, h1, h2, h3").each((_i, el) => {
+            const text = $(el).text().trim().toLowerCase();
+            const style = $(el).attr("style") || "";
+            // If element text IS the brand name (not just contains it in a paragraph)
+            // and has heavy styling — likely a logo approximation
+            if (text === nameLower &&
+                (style.includes("font-weight") ||
+                    style.includes("font-size") ||
+                    style.includes("letter-spacing") ||
+                    style.includes("text-transform"))) {
+                // Only flag if there's no SVG sibling or child
+                const parent = $(el).parent();
+                if (parent.find("svg").length === 0 && !hasSvg) {
+                    approxFound = true;
+                }
+            }
+        });
+    }
+    if (approxFound) {
+        checks.push({
+            id: "L-APPROX",
+            status: "warn",
+            message: "Possible logo approximation detected — brand name styled as text without SVG",
+            details: "Use actual logo SVG instead of styling brand name with CSS",
+        });
+    }
+    else {
+        checks.push({
+            id: "L-APPROX",
+            status: "pass",
+            message: "No logo approximation patterns detected",
+        });
+    }
+    return checks;
+}
+function checkAntiPatterns(css, antiPatterns) {
+    const checks = [];
+    let idx = 1;
+    for (const ap of antiPatterns) {
+        const id = ap.preflight_id || `A-${idx}`;
+        idx++;
+        const matched = matchAntiPattern(ap.rule, css);
+        if (matched) {
+            checks.push({
+                id,
+                status: ap.severity === "hard" ? "fail" : "warn",
+                message: ap.rule,
+                details: `Anti-pattern matched (severity: ${ap.severity})`,
+            });
+        }
+        else {
+            checks.push({
+                id,
+                status: "pass",
+                message: ap.rule,
+            });
+        }
+    }
+    return checks;
+}
+// ---------------------------------------------------------------------------
+// Main handlers
+// ---------------------------------------------------------------------------
+async function handleRules(brandDir) {
+    const identity = await brandDir.readCoreIdentity();
+    let antiPatterns = [];
+    if (await brandDir.hasVisualIdentity()) {
+        const vi = await brandDir.readVisualIdentity();
+        antiPatterns = vi.anti_patterns || [];
+    }
+    const rules = compileRules(identity, antiPatterns);
+    return buildResponse({
+        what_happened: `Compiled ${rules.length} preflight rules from brand system`,
+        next_steps: [
+            "Run brand_preflight with mode 'check' and HTML content to run compliance checks",
+            rules.some((r) => !r.checkable)
+                ? "Some rules are not checkable — add more data to core-identity.yaml"
+                : "All rules are checkable",
+        ],
+        data: {
+            rule_count: rules.length,
+            rules: rules,
+        },
+    });
+}
+async function handleCheck(brandDir, html) {
+    const identity = await brandDir.readCoreIdentity();
+    let antiPatterns = [];
+    if (await brandDir.hasVisualIdentity()) {
+        const vi = await brandDir.readVisualIdentity();
+        antiPatterns = vi.anti_patterns || [];
+    }
+    let clientName = "";
+    try {
+        const config = await brandDir.readConfig();
+        clientName = config.client_name || "";
+    }
+    catch {
+        // Non-critical — logo checks just won't match by name
+    }
+    // Parse HTML
+    const $ = cheerio.load(html);
+    const css = extractAllCss($);
+    // Run all checks
+    const checks = [
+        ...checkColors(css, identity),
+        ...checkTypography(css, identity),
+        ...checkLogo($, identity, clientName),
+        ...checkAntiPatterns(css, antiPatterns),
+    ];
+    // Compute summary
+    const pass = checks.filter((c) => c.status === "pass").length;
+    const warn = checks.filter((c) => c.status === "warn").length;
+    const fail = checks.filter((c) => c.status === "fail").length;
+    const overall = fail > 0 ? "FAIL" : warn > 0 ? "WARN" : "PASS";
+    const nextSteps = [];
+    if (fail > 0)
+        nextSteps.push("Fix failing checks (hard anti-patterns) before shipping");
+    if (warn > 0)
+        nextSteps.push("Review warnings — some may be intentional deviations");
+    if (fail === 0 && warn === 0)
+        nextSteps.push("All checks pass — content is brand-compliant");
+    return buildResponse({
+        what_happened: `Preflight ${overall}: ${pass} pass, ${warn} warn, ${fail} fail`,
+        next_steps: nextSteps,
+        data: {
+            overall,
+            summary: { pass, warn, fail },
+            checks: checks,
+        },
+    });
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+const paramsShape = {
+    html: z
+        .string()
+        .describe("HTML to validate: either a full HTML string (with <style> blocks) or a file path ending in .html (e.g. 'output.html')"),
+    mode: z
+        .enum(["check", "rules"])
+        .default("check")
+        .describe("'check' (default): validates HTML against all brand rules. 'rules': lists all active rules without running checks."),
+};
+const ParamsSchema = z.object(paramsShape);
+async function handler(input) {
+    const brandDir = new BrandDir(process.cwd());
+    if (!(await brandDir.exists())) {
+        return buildResponse({
+            what_happened: "No .brand/ directory found",
+            next_steps: ["Run brand_start to create a brand system first"],
+            data: { error: ERROR_CODES.NOT_INITIALIZED },
+        });
+    }
+    const mode = input.mode || "check";
+    if (mode === "rules") {
+        return handleRules(brandDir);
+    }
+    // Resolve HTML: if it looks like a file path, read it
+    let html = input.html;
+    if (!html.includes("<") &&
+        (html.endsWith(".html") || html.endsWith(".htm") || html.startsWith("/"))) {
+        const resolvedPath = resolve(process.cwd(), html);
+        if (!resolvedPath.startsWith(resolve(process.cwd()))) {
+            return buildResponse({
+                what_happened: "File path must be within the current working directory",
+                next_steps: ["Provide an HTML string or a file path within your project"],
+                data: { error: ERROR_CODES.PATH_OUTSIDE_CWD },
+            });
+        }
+        try {
+            html = await readFile(resolvedPath, "utf-8");
+        }
+        catch {
+            return buildResponse({
+                what_happened: `Could not read file: ${input.html}`,
+                next_steps: ["Provide valid HTML content or a readable file path"],
+                data: { error: ERROR_CODES.FILE_NOT_FOUND, path: input.html },
+            });
+        }
+    }
+    return handleCheck(brandDir, html);
+}
+export function register(server) {
+    server.tool("brand_preflight", "Check HTML/CSS against brand rules — catches off-brand colors, wrong fonts, missing logo, and anti-pattern violations (drop shadows, gradients, etc.). Pass an HTML string or file path. Mode 'check' (default) runs all compliance checks and returns pass/warn/fail per rule. Mode 'rules' lists all active preflight rules without checking content. Use after generating any visual content to validate brand compliance. Returns overall status and per-check details. NOT for scoring content copy — use brand_audit_content. NOT for brand directory validation — use brand_audit.", paramsShape, async (args) => {
+        const parsed = safeParseParams(ParamsSchema, args);
+        if (!parsed.success)
+            return parsed.response;
+        return handler(parsed.data);
+    });
+}
+//# sourceMappingURL=brand-preflight.js.map