canicode 0.3.0

package/dist/mcp/server.js

@@ -0,0 +1,3009 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { config } from 'dotenv';
+import { z } from 'zod';
+import { writeFile, existsSync, mkdirSync, readFileSync } from 'fs';
+import { exec } from 'child_process';
+import { join, resolve, basename } from 'path';
+import { readFile } from 'fs/promises';
+import { homedir } from 'os';
+
+var CategorySchema = z.enum([
+  "layout",
+  "token",
+  "component",
+  "naming",
+  "ai-readability",
+  "handoff-risk"
+]);
+var CATEGORIES = CategorySchema.options;
+var CATEGORY_LABELS = {
+  layout: "Layout",
+  token: "Design Token",
+  component: "Component",
+  naming: "Naming",
+  "ai-readability": "AI Readability",
+  "handoff-risk": "Handoff Risk"
+};
+var SeveritySchema = z.enum([
+  "blocking",
+  "risk",
+  "missing-info",
+  "suggestion"
+]);
+var SEVERITY_LABELS = {
+  blocking: "Blocking",
+  risk: "Risk",
+  "missing-info": "Missing Info",
+  suggestion: "Suggestion"
+};
+
+// src/contracts/rule.ts
+z.object({
+  id: z.string(),
+  name: z.string(),
+  category: CategorySchema,
+  why: z.string(),
+  impact: z.string(),
+  fix: z.string()
+});
+z.object({
+  severity: SeveritySchema,
+  score: z.number().int().max(0),
+  depthWeight: z.number().min(1).max(2).optional(),
+  enabled: z.boolean().default(true),
+  options: z.record(z.string(), z.unknown()).optional()
+});
+var DEPTH_WEIGHT_CATEGORIES = ["layout", "handoff-risk"];
+function supportsDepthWeight(category) {
+  return DEPTH_WEIGHT_CATEGORIES.includes(category);
+}
+
+// src/rules/rule-config.ts
+var RULE_CONFIGS = {
+  // ============================================
+  // Layout (11 rules)
+  // ============================================
+  "no-auto-layout": {
+    severity: "blocking",
+    score: -7,
+    depthWeight: 1.5,
+    enabled: true
+  },
+  "absolute-position-in-auto-layout": {
+    severity: "blocking",
+    score: -10,
+    depthWeight: 1.3,
+    enabled: true
+  },
+  "fixed-width-in-responsive-context": {
+    severity: "risk",
+    score: -4,
+    depthWeight: 1.3,
+    enabled: true
+  },
+  "missing-responsive-behavior": {
+    severity: "risk",
+    score: -4,
+    depthWeight: 1.5,
+    enabled: true
+  },
+  "group-usage": {
+    severity: "risk",
+    score: -5,
+    depthWeight: 1.2,
+    enabled: true
+  },
+  "fixed-size-in-auto-layout": {
+    severity: "risk",
+    score: -5,
+    enabled: true
+  },
+  "missing-min-width": {
+    severity: "risk",
+    score: -5,
+    enabled: true
+  },
+  "missing-max-width": {
+    severity: "risk",
+    score: -4,
+    enabled: true
+  },
+  "deep-nesting": {
+    severity: "risk",
+    score: -4,
+    enabled: true,
+    options: {
+      maxDepth: 5
+    }
+  },
+  "overflow-hidden-abuse": {
+    severity: "missing-info",
+    score: -3,
+    enabled: true
+  },
+  "inconsistent-sibling-layout-direction": {
+    severity: "missing-info",
+    score: -2,
+    enabled: true
+  },
+  // ============================================
+  // Token (7 rules)
+  // ============================================
+  "raw-color": {
+    severity: "missing-info",
+    score: -2,
+    enabled: true
+  },
+  "raw-font": {
+    severity: "blocking",
+    score: -8,
+    enabled: true
+  },
+  "inconsistent-spacing": {
+    severity: "missing-info",
+    score: -2,
+    enabled: true,
+    options: {
+      gridBase: 8
+    }
+  },
+  "magic-number-spacing": {
+    severity: "risk",
+    score: -4,
+    enabled: true,
+    options: {
+      gridBase: 8
+    }
+  },
+  "raw-shadow": {
+    severity: "missing-info",
+    score: -3,
+    enabled: true
+  },
+  "raw-opacity": {
+    severity: "missing-info",
+    score: -2,
+    enabled: true
+  },
+  "multiple-fill-colors": {
+    severity: "missing-info",
+    score: -3,
+    enabled: true,
+    options: {
+      tolerance: 10
+    }
+  },
+  // ============================================
+  // Component (6 rules)
+  // ============================================
+  "missing-component": {
+    severity: "risk",
+    score: -7,
+    enabled: true,
+    options: {
+      minRepetitions: 3
+    }
+  },
+  "detached-instance": {
+    severity: "risk",
+    score: -5,
+    enabled: true
+  },
+  "nested-instance-override": {
+    severity: "risk",
+    score: -5,
+    enabled: true
+  },
+  "variant-not-used": {
+    severity: "missing-info",
+    score: -3,
+    enabled: true
+  },
+  "component-property-unused": {
+    severity: "missing-info",
+    score: -2,
+    enabled: true
+  },
+  "single-use-component": {
+    severity: "suggestion",
+    score: -1,
+    enabled: true
+  },
+  // ============================================
+  // Naming (5 rules)
+  // ============================================
+  "default-name": {
+    severity: "missing-info",
+    score: -2,
+    enabled: true
+  },
+  "non-semantic-name": {
+    severity: "missing-info",
+    score: -2,
+    enabled: true
+  },
+  "inconsistent-naming-convention": {
+    severity: "missing-info",
+    score: -2,
+    enabled: true
+  },
+  "numeric-suffix-name": {
+    severity: "suggestion",
+    score: -1,
+    enabled: true
+  },
+  "too-long-name": {
+    severity: "suggestion",
+    score: -1,
+    enabled: true,
+    options: {
+      maxLength: 50
+    }
+  },
+  // ============================================
+  // AI Readability (5 rules)
+  // ============================================
+  "ambiguous-structure": {
+    severity: "blocking",
+    score: -10,
+    depthWeight: 1.3,
+    enabled: true
+  },
+  "z-index-dependent-layout": {
+    severity: "risk",
+    score: -5,
+    depthWeight: 1.3,
+    enabled: true
+  },
+  "missing-layout-hint": {
+    severity: "risk",
+    score: -5,
+    enabled: true
+  },
+  "invisible-layer": {
+    severity: "blocking",
+    score: -10,
+    enabled: true
+  },
+  "empty-frame": {
+    severity: "missing-info",
+    score: -2,
+    enabled: true
+  },
+  // ============================================
+  // Handoff Risk (5 rules)
+  // ============================================
+  "hardcode-risk": {
+    severity: "risk",
+    score: -5,
+    depthWeight: 1.5,
+    enabled: true
+  },
+  "text-truncation-unhandled": {
+    severity: "risk",
+    score: -5,
+    enabled: true
+  },
+  "image-no-placeholder": {
+    severity: "missing-info",
+    score: -3,
+    enabled: true
+  },
+  "prototype-link-in-design": {
+    severity: "missing-info",
+    score: -2,
+    enabled: true
+  },
+  "no-dev-status": {
+    severity: "missing-info",
+    score: -2,
+    enabled: false
+    // Disabled by default
+  }
+};
+function getConfigsWithPreset(preset) {
+  const configs = { ...RULE_CONFIGS };
+  switch (preset) {
+    case "relaxed":
+      for (const [id, config2] of Object.entries(configs)) {
+        if (config2.severity === "blocking") {
+          configs[id] = {
+            ...config2,
+            severity: "risk",
+            score: Math.round(config2.score * 0.5)
+          };
+        }
+      }
+      break;
+    case "dev-friendly":
+      for (const [id, config2] of Object.entries(configs)) {
+        const ruleId = id;
+        if (!ruleId.includes("layout") && !ruleId.includes("handoff") && !ruleId.includes("responsive")) {
+          configs[ruleId] = { ...config2, enabled: false };
+        }
+      }
+      break;
+    case "ai-ready":
+      for (const [id, config2] of Object.entries(configs)) {
+        const ruleId = id;
+        if (ruleId.includes("ambiguous") || ruleId.includes("structure") || ruleId.includes("name")) {
+          configs[ruleId] = {
+            ...config2,
+            score: Math.round(config2.score * 1.5)
+          };
+        }
+      }
+      break;
+    case "strict":
+      for (const [id, config2] of Object.entries(configs)) {
+        configs[id] = {
+          ...config2,
+          enabled: true,
+          score: Math.round(config2.score * 1.5)
+        };
+      }
+      break;
+  }
+  return configs;
+}
+function getRuleOption(ruleId, optionKey, defaultValue) {
+  const config2 = RULE_CONFIGS[ruleId];
+  if (!config2.options) return defaultValue;
+  const value = config2.options[optionKey];
+  return value ?? defaultValue;
+}
+
+// src/rules/rule-registry.ts
+var RuleRegistry = class {
+  rules = /* @__PURE__ */ new Map();
+  /**
+   * Register a rule
+   */
+  register(rule) {
+    this.rules.set(rule.definition.id, rule);
+  }
+  /**
+   * Get a rule by ID
+   */
+  get(id) {
+    return this.rules.get(id);
+  }
+  /**
+   * Get all registered rules
+   */
+  getAll() {
+    return Array.from(this.rules.values());
+  }
+  /**
+   * Get rules by category
+   */
+  getByCategory(category) {
+    return this.getAll().filter((rule) => rule.definition.category === category);
+  }
+  /**
+   * Get enabled rules with their configs
+   */
+  getEnabled(configs = RULE_CONFIGS) {
+    return this.getAll().filter((rule) => {
+      const config2 = configs[rule.definition.id];
+      return config2?.enabled ?? true;
+    });
+  }
+  /**
+   * Get config for a rule
+   */
+  getConfig(id, configs = RULE_CONFIGS) {
+    return configs[id];
+  }
+  /**
+   * Check if a rule is registered
+   */
+  has(id) {
+    return this.rules.has(id);
+  }
+  /**
+   * Get count of registered rules
+   */
+  get size() {
+    return this.rules.size;
+  }
+};
+var ruleRegistry = new RuleRegistry();
+function defineRule(rule) {
+  ruleRegistry.register(rule);
+  return rule;
+}
+
+// src/core/rule-engine.ts
+function calculateMaxDepth(node, currentDepth = 0) {
+  if (!node.children || node.children.length === 0) {
+    return currentDepth;
+  }
+  let maxChildDepth = currentDepth;
+  for (const child of node.children) {
+    const childDepth = calculateMaxDepth(child, currentDepth + 1);
+    if (childDepth > maxChildDepth) {
+      maxChildDepth = childDepth;
+    }
+  }
+  return maxChildDepth;
+}
+function countNodes(node) {
+  let count = 1;
+  if (node.children) {
+    for (const child of node.children) {
+      count += countNodes(child);
+    }
+  }
+  return count;
+}
+function findNodeById(node, nodeId) {
+  const normalizedId = nodeId.replace(/-/g, ":");
+  if (node.id === normalizedId) {
+    return node;
+  }
+  if (node.children) {
+    for (const child of node.children) {
+      const found = findNodeById(child, nodeId);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+function calcDepthWeight(depth, maxDepth, depthWeight) {
+  if (!depthWeight || depthWeight <= 1) return 1;
+  if (maxDepth === 0) return depthWeight;
+  const ratio = depth / maxDepth;
+  return depthWeight - (depthWeight - 1) * ratio;
+}
+var RuleEngine = class {
+  configs;
+  enabledRuleIds;
+  disabledRuleIds;
+  targetNodeId;
+  constructor(options = {}) {
+    this.configs = options.configs ?? RULE_CONFIGS;
+    this.enabledRuleIds = options.enabledRules ? new Set(options.enabledRules) : null;
+    this.disabledRuleIds = new Set(options.disabledRules ?? []);
+    this.targetNodeId = options.targetNodeId;
+  }
+  /**
+   * Analyze a Figma file and return issues
+   */
+  analyze(file) {
+    let rootNode = file.document;
+    if (this.targetNodeId) {
+      const targetNode = findNodeById(file.document, this.targetNodeId);
+      if (!targetNode) {
+        throw new Error(`Node not found: ${this.targetNodeId}`);
+      }
+      rootNode = targetNode;
+    }
+    const maxDepth = calculateMaxDepth(rootNode);
+    const nodeCount = countNodes(rootNode);
+    const issues = [];
+    const enabledRules = this.getEnabledRules();
+    this.traverseAndCheck(
+      rootNode,
+      file,
+      enabledRules,
+      maxDepth,
+      issues,
+      0,
+      [],
+      void 0,
+      void 0
+    );
+    return {
+      file,
+      issues,
+      maxDepth,
+      nodeCount,
+      analyzedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Get rules that should be run based on configuration
+   */
+  getEnabledRules() {
+    return ruleRegistry.getAll().filter((rule) => {
+      const ruleId = rule.definition.id;
+      if (this.disabledRuleIds.has(ruleId)) return false;
+      if (this.enabledRuleIds && !this.enabledRuleIds.has(ruleId)) return false;
+      const config2 = this.configs[ruleId];
+      return config2?.enabled ?? true;
+    });
+  }
+  /**
+   * Recursively traverse the tree and run rules
+   */
+  traverseAndCheck(node, file, rules, maxDepth, issues, depth, path, parent, siblings) {
+    const nodePath = [...path, node.name];
+    const context = {
+      file,
+      parent,
+      depth,
+      maxDepth,
+      path: nodePath,
+      siblings
+    };
+    for (const rule of rules) {
+      const ruleId = rule.definition.id;
+      const config2 = this.configs[ruleId];
+      const options = config2?.options;
+      try {
+        const violation = rule.check(node, context, options);
+        if (violation) {
+          let calculatedScore = config2.score;
+          if (supportsDepthWeight(rule.definition.category) && config2.depthWeight) {
+            const weight = calcDepthWeight(depth, maxDepth, config2.depthWeight);
+            calculatedScore = Math.round(config2.score * weight);
+          }
+          issues.push({
+            violation,
+            rule,
+            config: config2,
+            depth,
+            maxDepth,
+            calculatedScore
+          });
+        }
+      } catch (error) {
+        console.error(`Rule "${ruleId}" threw error on node "${node.name}":`, error);
+      }
+    }
+    if (node.children && node.children.length > 0) {
+      for (const child of node.children) {
+        this.traverseAndCheck(
+          child,
+          file,
+          rules,
+          maxDepth,
+          issues,
+          depth + 1,
+          nodePath,
+          node,
+          node.children
+        );
+      }
+    }
+  }
+};
+function createRuleEngine(options) {
+  return new RuleEngine(options);
+}
+function analyzeFile(file, options) {
+  const engine = createRuleEngine(options);
+  return engine.analyze(file);
+}
+
+// src/adapters/figma-client.ts
+var FIGMA_API_BASE = "https://api.figma.com/v1";
+var FigmaClient = class _FigmaClient {
+  token;
+  constructor(options) {
+    this.token = options.token;
+  }
+  static fromEnv() {
+    const token = process.env["FIGMA_TOKEN"];
+    if (!token) {
+      throw new FigmaClientError(
+        "FIGMA_TOKEN environment variable is not set"
+      );
+    }
+    return new _FigmaClient({ token });
+  }
+  async getFile(fileKey) {
+    const url = `${FIGMA_API_BASE}/files/${fileKey}`;
+    const response = await fetch(url, {
+      headers: {
+        "X-Figma-Token": this.token
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new FigmaClientError(
+        `Failed to fetch file: ${response.status} ${response.statusText}`,
+        response.status,
+        error
+      );
+    }
+    return response.json();
+  }
+  /**
+   * Get rendered images for specific nodes
+   * Returns a map of nodeId → image URL
+   */
+  async getNodeImages(fileKey, nodeIds, options) {
+    const format = options?.format ?? "png";
+    const scale = options?.scale ?? 2;
+    const BATCH_SIZE = 50;
+    const allImages = {};
+    for (let i = 0; i < nodeIds.length; i += BATCH_SIZE) {
+      const batch = nodeIds.slice(i, i + BATCH_SIZE);
+      const ids = batch.join(",");
+      const url = `${FIGMA_API_BASE}/images/${fileKey}?ids=${encodeURIComponent(ids)}&format=${format}&scale=${scale}`;
+      const response = await fetch(url, {
+        headers: {
+          "X-Figma-Token": this.token
+        }
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new FigmaClientError(
+          `Failed to fetch images: ${response.status} ${response.statusText}`,
+          response.status,
+          error
+        );
+      }
+      const data = await response.json();
+      for (const [nodeId, imageUrl] of Object.entries(data.images)) {
+        allImages[nodeId] = imageUrl;
+      }
+    }
+    return allImages;
+  }
+  /**
+   * Download an image URL and return as base64
+   */
+  async fetchImageAsBase64(imageUrl) {
+    const response = await fetch(imageUrl);
+    if (!response.ok) {
+      throw new FigmaClientError(
+        `Failed to download image: ${response.status}`,
+        response.status
+      );
+    }
+    const buffer = await response.arrayBuffer();
+    return Buffer.from(buffer).toString("base64");
+  }
+  async getFileNodes(fileKey, nodeIds) {
+    const ids = nodeIds.join(",");
+    const url = `${FIGMA_API_BASE}/files/${fileKey}/nodes?ids=${encodeURIComponent(ids)}`;
+    const response = await fetch(url, {
+      headers: {
+        "X-Figma-Token": this.token
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new FigmaClientError(
+        `Failed to fetch nodes: ${response.status} ${response.statusText}`,
+        response.status,
+        error
+      );
+    }
+    return response.json();
+  }
+};
+var FigmaClientError = class extends Error {
+  constructor(message, statusCode, responseBody) {
+    super(message);
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+    this.name = "FigmaClientError";
+  }
+};
+
+// src/adapters/figma-transformer.ts
+function transformFigmaResponse(fileKey, response) {
+  return {
+    fileKey,
+    name: response.name,
+    lastModified: response.lastModified,
+    version: response.version,
+    document: transformNode(response.document),
+    components: transformComponents(response.components),
+    styles: transformStyles(response.styles)
+  };
+}
+function transformNode(node) {
+  const base = {
+    id: node.id,
+    name: node.name,
+    type: node.type,
+    visible: "visible" in node ? node.visible ?? true : true
+  };
+  if ("layoutMode" in node && node.layoutMode) {
+    base.layoutMode = node.layoutMode;
+  }
+  if ("layoutAlign" in node && node.layoutAlign) {
+    base.layoutAlign = node.layoutAlign;
+  }
+  if ("layoutPositioning" in node && node.layoutPositioning) {
+    base.layoutPositioning = node.layoutPositioning;
+  }
+  if ("primaryAxisAlignItems" in node) {
+    base.primaryAxisAlignItems = node.primaryAxisAlignItems;
+  }
+  if ("counterAxisAlignItems" in node) {
+    base.counterAxisAlignItems = node.counterAxisAlignItems;
+  }
+  if ("itemSpacing" in node) {
+    base.itemSpacing = node.itemSpacing;
+  }
+  if ("paddingLeft" in node) {
+    base.paddingLeft = node.paddingLeft;
+  }
+  if ("paddingRight" in node) {
+    base.paddingRight = node.paddingRight;
+  }
+  if ("paddingTop" in node) {
+    base.paddingTop = node.paddingTop;
+  }
+  if ("paddingBottom" in node) {
+    base.paddingBottom = node.paddingBottom;
+  }
+  if ("absoluteBoundingBox" in node && node.absoluteBoundingBox) {
+    base.absoluteBoundingBox = node.absoluteBoundingBox;
+  }
+  if ("componentId" in node) {
+    base.componentId = node.componentId;
+  }
+  if ("componentPropertyDefinitions" in node) {
+    base.componentPropertyDefinitions = node.componentPropertyDefinitions;
+  }
+  if ("componentProperties" in node) {
+    base.componentProperties = node.componentProperties;
+  }
+  if ("styles" in node) {
+    base.styles = node.styles;
+  }
+  if ("fills" in node) {
+    base.fills = node.fills;
+  }
+  if ("strokes" in node) {
+    base.strokes = node.strokes;
+  }
+  if ("effects" in node) {
+    base.effects = node.effects;
+  }
+  if ("boundVariables" in node && node.boundVariables) {
+    base.boundVariables = node.boundVariables;
+  }
+  if ("characters" in node) {
+    base.characters = node.characters;
+  }
+  if ("style" in node) {
+    base.style = node.style;
+  }
+  if ("devStatus" in node && node.devStatus) {
+    base.devStatus = node.devStatus;
+  }
+  if ("children" in node && Array.isArray(node.children)) {
+    base.children = node.children.map(transformNode);
+  }
+  return base;
+}
+function transformComponents(components) {
+  const result = {};
+  for (const [id, component] of Object.entries(components)) {
+    result[id] = {
+      key: component.key,
+      name: component.name,
+      description: component.description
+    };
+  }
+  return result;
+}
+function transformStyles(styles) {
+  const result = {};
+  for (const [id, style] of Object.entries(styles)) {
+    result[id] = {
+      key: style.key,
+      name: style.name,
+      styleType: style.styleType
+    };
+  }
+  return result;
+}
+
+// src/adapters/figma-file-loader.ts
+async function loadFigmaFileFromJson(filePath) {
+  const content = await readFile(filePath, "utf-8");
+  const data = JSON.parse(content);
+  const fileKey = basename(filePath, ".json");
+  return transformFigmaResponse(fileKey, data);
+}
+z.object({
+  fileKey: z.string(),
+  nodeId: z.string().optional(),
+  fileName: z.string().optional()
+});
+var FIGMA_URL_PATTERNS = [
+  // https://www.figma.com/design/FILE_KEY/FILE_NAME?node-id=NODE_ID
+  /figma\.com\/design\/([a-zA-Z0-9]+)(?:\/([^?]+))?(?:\?.*node-id=([^&]+))?/,
+  // https://www.figma.com/file/FILE_KEY/FILE_NAME?node-id=NODE_ID
+  /figma\.com\/file\/([a-zA-Z0-9]+)(?:\/([^?]+))?(?:\?.*node-id=([^&]+))?/,
+  // https://www.figma.com/proto/FILE_KEY/FILE_NAME?node-id=NODE_ID
+  /figma\.com\/proto\/([a-zA-Z0-9]+)(?:\/([^?]+))?(?:\?.*node-id=([^&]+))?/
+];
+function parseFigmaUrl(url) {
+  for (const pattern of FIGMA_URL_PATTERNS) {
+    const match = url.match(pattern);
+    if (match) {
+      const [, fileKey, fileName, nodeId] = match;
+      if (!fileKey) {
+        throw new FigmaUrlParseError(`Invalid Figma URL: missing file key`);
+      }
+      return {
+        fileKey,
+        fileName: fileName ? decodeURIComponent(fileName) : void 0,
+        nodeId: nodeId ? decodeURIComponent(nodeId) : void 0
+      };
+    }
+  }
+  throw new FigmaUrlParseError(
+    `Invalid Figma URL format. Expected: https://www.figma.com/design/FILE_KEY/...`
+  );
+}
+var FigmaUrlParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FigmaUrlParseError";
+  }
+};
+function buildFigmaDeepLink(fileKey, nodeId) {
+  return `https://www.figma.com/design/${fileKey}?node-id=${encodeURIComponent(nodeId)}`;
+}
+
+// src/adapters/figma-mcp-adapter.ts
+var TAG_TYPE_MAP = {
+  canvas: "CANVAS",
+  frame: "FRAME",
+  group: "GROUP",
+  section: "SECTION",
+  component: "COMPONENT",
+  "component-set": "COMPONENT_SET",
+  instance: "INSTANCE",
+  rectangle: "RECTANGLE",
+  "rounded-rectangle": "RECTANGLE",
+  ellipse: "ELLIPSE",
+  vector: "VECTOR",
+  text: "TEXT",
+  line: "LINE",
+  "boolean-operation": "BOOLEAN_OPERATION",
+  star: "STAR",
+  "regular-polygon": "REGULAR_POLYGON",
+  slice: "SLICE",
+  sticky: "STICKY",
+  table: "TABLE",
+  "table-cell": "TABLE_CELL",
+  symbol: "COMPONENT",
+  slot: "FRAME"
+};
+function parseXml(xml) {
+  const nodes = [];
+  const stack = [];
+  const tagRegex = /<(\/?)([\w-]+)([^>]*?)(\/?)>/g;
+  let match;
+  while ((match = tagRegex.exec(xml)) !== null) {
+    const isClosing = match[1] === "/";
+    const tagName = match[2];
+    const attrString = match[3] ?? "";
+    const isSelfClosing = match[4] === "/";
+    if (isClosing) {
+      const finished = stack.pop();
+      if (finished) {
+        const parent = stack[stack.length - 1];
+        if (parent) {
+          parent.children.push(finished);
+        } else {
+          nodes.push(finished);
+        }
+      }
+    } else {
+      const attrs = parseAttributes(attrString);
+      const node = { tag: tagName, attrs, children: [] };
+      if (isSelfClosing) {
+        const parent = stack[stack.length - 1];
+        if (parent) {
+          parent.children.push(node);
+        } else {
+          nodes.push(node);
+        }
+      } else {
+        stack.push(node);
+      }
+    }
+  }
+  while (stack.length > 0) {
+    const finished = stack.pop();
+    const parent = stack[stack.length - 1];
+    if (parent) {
+      parent.children.push(finished);
+    } else {
+      nodes.push(finished);
+    }
+  }
+  return nodes;
+}
+function parseAttributes(attrString) {
+  const attrs = {};
+  const attrRegex = /([\w-]+)="([^"]*)"/g;
+  let match;
+  while ((match = attrRegex.exec(attrString)) !== null) {
+    const key = match[1];
+    const value = match[2];
+    if (key && value !== void 0) {
+      attrs[key] = value;
+    }
+  }
+  return attrs;
+}
+function toAnalysisNode(xmlNode) {
+  const type = TAG_TYPE_MAP[xmlNode.tag] ?? "FRAME";
+  const id = xmlNode.attrs["id"] ?? "0:0";
+  const name = xmlNode.attrs["name"] ?? xmlNode.tag;
+  const hidden = xmlNode.attrs["hidden"] === "true";
+  const x = parseFloat(xmlNode.attrs["x"] ?? "0");
+  const y = parseFloat(xmlNode.attrs["y"] ?? "0");
+  const width = parseFloat(xmlNode.attrs["width"] ?? "0");
+  const height = parseFloat(xmlNode.attrs["height"] ?? "0");
+  const node = {
+    id,
+    name,
+    type,
+    visible: !hidden,
+    absoluteBoundingBox: { x, y, width, height }
+  };
+  if (xmlNode.children.length > 0) {
+    node.children = xmlNode.children.map(toAnalysisNode);
+  }
+  return node;
+}
+function parseMcpMetadataXml(xml, fileKey, fileName) {
+  const parsed = parseXml(xml);
+  const children = parsed.map(toAnalysisNode);
+  let document;
+  if (children.length === 1 && children[0]) {
+    document = children[0];
+  } else {
+    document = {
+      id: "0:0",
+      name: "Document",
+      type: "DOCUMENT",
+      visible: true,
+      children
+    };
+  }
+  return {
+    fileKey,
+    name: fileName ?? fileKey,
+    lastModified: (/* @__PURE__ */ new Date()).toISOString(),
+    version: "mcp",
+    document,
+    components: {},
+    styles: {}
+  };
+}
+var AIREADY_DIR = join(homedir(), ".canicode");
+var CONFIG_PATH = join(AIREADY_DIR, "config.json");
+var REPORTS_DIR = join(AIREADY_DIR, "reports");
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function readConfig() {
+  if (!existsSync(CONFIG_PATH)) {
+    return {};
+  }
+  try {
+    const raw = readFileSync(CONFIG_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function getFigmaToken() {
+  return process.env["FIGMA_TOKEN"] ?? readConfig().figmaToken;
+}
+function getReportsDir() {
+  return REPORTS_DIR;
+}
+function ensureReportsDir() {
+  ensureDir(REPORTS_DIR);
+}
+
+// src/core/loader.ts
+function isFigmaUrl(input) {
+  return input.includes("figma.com/");
+}
+function isJsonFile(input) {
+  return input.endsWith(".json");
+}
+async function loadFile(input, token, mode = "auto") {
+  if (isJsonFile(input)) {
+    const filePath = resolve(input);
+    if (!existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    console.log(`Loading from JSON: ${filePath}`);
+    return { file: await loadFigmaFileFromJson(filePath) };
+  }
+  if (isFigmaUrl(input)) {
+    const { fileKey, nodeId, fileName } = parseFigmaUrl(input);
+    if (mode === "mcp") {
+      return loadFromMcp(fileKey, nodeId, fileName);
+    }
+    if (mode === "api") {
+      return loadFromApi(fileKey, nodeId, token);
+    }
+    try {
+      console.log("Auto-detecting data source... trying MCP first.");
+      return await loadFromMcp(fileKey, nodeId, fileName);
+    } catch (mcpError) {
+      const mcpMsg = mcpError instanceof Error ? mcpError.message : String(mcpError);
+      console.log(`MCP unavailable (${mcpMsg}). Falling back to REST API.`);
+      return loadFromApi(fileKey, nodeId, token);
+    }
+  }
+  throw new Error(
+    `Invalid input: ${input}. Provide a Figma URL or JSON file path.`
+  );
+}
+async function loadFromMcp(fileKey, nodeId, fileName) {
+  console.log(`Loading via MCP: ${fileKey} (node: ${nodeId ?? "root"})`);
+  const file = await loadViaMcp(fileKey, nodeId ?? "0:1", fileName);
+  return { file, nodeId };
+}
+async function loadFromApi(fileKey, nodeId, token) {
+  console.log(`Fetching from Figma REST API: ${fileKey}`);
+  if (nodeId) {
+    console.log(`Target node: ${nodeId}`);
+  }
+  const figmaToken = token ?? getFigmaToken();
+  if (!figmaToken) {
+    throw new Error(
+      "Figma token required. Run 'canicode init --token YOUR_TOKEN' or set FIGMA_TOKEN env var."
+    );
+  }
+  const client = new FigmaClient({ token: figmaToken });
+  const response = await client.getFile(fileKey);
+  return {
+    file: transformFigmaResponse(fileKey, response),
+    nodeId
+  };
+}
+async function loadViaMcp(fileKey, nodeId, fileName) {
+  const { execSync } = await import('child_process');
+  const result = execSync(
+    `claude --print "Use the mcp__figma__get_metadata tool with fileKey=\\"${fileKey}\\" and nodeId=\\"${nodeId.replace(/-/g, ":")}\\" \u2014 return ONLY the raw XML output, nothing else."`,
+    { encoding: "utf-8", timeout: 12e4 }
+  );
+  const xmlStart = result.indexOf("<");
+  const xmlEnd = result.lastIndexOf(">");
+  if (xmlStart === -1 || xmlEnd === -1) {
+    throw new Error("MCP did not return valid XML metadata");
+  }
+  const xml = result.slice(xmlStart, xmlEnd + 1);
+  return parseMcpMetadataXml(xml, fileKey, fileName);
+}
+
+// src/core/design-data-parser.ts
+function parseDesignData(data, fileKey, fileName) {
+  const trimmed = data.trim();
+  if (trimmed.startsWith("<")) {
+    return parseMcpMetadataXml(trimmed, fileKey, fileName);
+  }
+  const parsed = JSON.parse(trimmed);
+  if ("fileKey" in parsed && "document" in parsed) {
+    return parsed;
+  }
+  if ("document" in parsed && "name" in parsed) {
+    return transformFigmaResponse(fileKey, parsed);
+  }
+  throw new Error(
+    "Unrecognized designData format. Expected XML from Figma MCP get_metadata, AnalysisFile JSON, or Figma REST API JSON."
+  );
+}
+
+// src/core/scoring.ts
+var SEVERITY_DENSITY_WEIGHT = {
+  blocking: 3,
+  risk: 2,
+  "missing-info": 1,
+  suggestion: 0.5
+};
+var TOTAL_RULES_PER_CATEGORY = {
+  layout: 11,
+  token: 7,
+  component: 6,
+  naming: 5,
+  "ai-readability": 5,
+  "handoff-risk": 5
+};
+var CATEGORY_WEIGHT = {
+  layout: 1,
+  token: 1,
+  component: 1,
+  naming: 1,
+  "ai-readability": 1,
+  "handoff-risk": 1
+};
+var DENSITY_WEIGHT = 0.7;
+var DIVERSITY_WEIGHT = 0.3;
+var SCORE_FLOOR = 5;
+function calculateGrade(percentage) {
+  if (percentage >= 95) return "S";
+  if (percentage >= 90) return "A+";
+  if (percentage >= 85) return "A";
+  if (percentage >= 80) return "B+";
+  if (percentage >= 75) return "B";
+  if (percentage >= 70) return "C+";
+  if (percentage >= 65) return "C";
+  if (percentage >= 50) return "D";
+  return "F";
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function calculateScores(result) {
+  const categoryScores = initializeCategoryScores();
+  const nodeCount = result.nodeCount;
+  const uniqueRulesPerCategory = /* @__PURE__ */ new Map();
+  for (const category of CATEGORIES) {
+    uniqueRulesPerCategory.set(category, /* @__PURE__ */ new Set());
+  }
+  for (const issue of result.issues) {
+    const category = issue.rule.definition.category;
+    const severity = issue.config.severity;
+    const ruleId = issue.rule.definition.id;
+    categoryScores[category].issueCount++;
+    categoryScores[category].bySeverity[severity]++;
+    categoryScores[category].weightedIssueCount += SEVERITY_DENSITY_WEIGHT[severity];
+    uniqueRulesPerCategory.get(category).add(ruleId);
+  }
+  for (const category of CATEGORIES) {
+    const catScore = categoryScores[category];
+    const uniqueRules = uniqueRulesPerCategory.get(category);
+    const totalRules = TOTAL_RULES_PER_CATEGORY[category];
+    catScore.uniqueRuleCount = uniqueRules.size;
+    let densityScore = 100;
+    if (nodeCount > 0 && catScore.issueCount > 0) {
+      const density = catScore.weightedIssueCount / nodeCount;
+      densityScore = clamp(Math.round(100 - density * 100), 0, 100);
+    }
+    catScore.densityScore = densityScore;
+    let diversityScore = 100;
+    if (catScore.issueCount > 0) {
+      const diversityRatio = uniqueRules.size / totalRules;
+      diversityScore = clamp(Math.round((1 - diversityRatio) * 100), 0, 100);
+    }
+    catScore.diversityScore = diversityScore;
+    const combinedScore = densityScore * DENSITY_WEIGHT + diversityScore * DIVERSITY_WEIGHT;
+    catScore.percentage = catScore.issueCount > 0 ? clamp(Math.round(combinedScore), SCORE_FLOOR, 100) : 100;
+    catScore.score = catScore.percentage;
+    catScore.maxScore = 100;
+  }
+  let totalWeight = 0;
+  let weightedSum = 0;
+  for (const category of CATEGORIES) {
+    const weight = CATEGORY_WEIGHT[category];
+    weightedSum += categoryScores[category].percentage * weight;
+    totalWeight += weight;
+  }
+  const overallPercentage = totalWeight > 0 ? Math.round(weightedSum / totalWeight) : 100;
+  const summary = {
+    totalIssues: result.issues.length,
+    blocking: 0,
+    risk: 0,
+    missingInfo: 0,
+    suggestion: 0,
+    nodeCount
+  };
+  for (const issue of result.issues) {
+    switch (issue.config.severity) {
+      case "blocking":
+        summary.blocking++;
+        break;
+      case "risk":
+        summary.risk++;
+        break;
+      case "missing-info":
+        summary.missingInfo++;
+        break;
+      case "suggestion":
+        summary.suggestion++;
+        break;
+    }
+  }
+  return {
+    overall: {
+      score: overallPercentage,
+      maxScore: 100,
+      percentage: overallPercentage,
+      grade: calculateGrade(overallPercentage)
+    },
+    byCategory: categoryScores,
+    summary
+  };
+}
+function initializeCategoryScores() {
+  const scores = {};
+  for (const category of CATEGORIES) {
+    scores[category] = {
+      category,
+      score: 100,
+      maxScore: 100,
+      percentage: 100,
+      issueCount: 0,
+      uniqueRuleCount: 0,
+      weightedIssueCount: 0,
+      densityScore: 100,
+      diversityScore: 100,
+      bySeverity: {
+        blocking: 0,
+        risk: 0,
+        "missing-info": 0,
+        suggestion: 0
+      }
+    };
+  }
+  return scores;
+}
+function formatScoreSummary(report) {
+  const lines = [];
+  lines.push(`Overall: ${report.overall.grade} (${report.overall.percentage}%)`);
+  lines.push("");
+  lines.push("By Category:");
+  for (const category of CATEGORIES) {
+    const cat = report.byCategory[category];
+    lines.push(`  ${category}: ${cat.percentage}% (${cat.issueCount} issues, ${cat.uniqueRuleCount} rules)`);
+  }
+  lines.push("");
+  lines.push("Issues:");
+  lines.push(`  Blocking: ${report.summary.blocking}`);
+  lines.push(`  Risk: ${report.summary.risk}`);
+  lines.push(`  Missing Info: ${report.summary.missingInfo}`);
+  lines.push(`  Suggestion: ${report.summary.suggestion}`);
+  lines.push(`  Total: ${report.summary.totalIssues}`);
+  return lines.join("\n");
+}
+
+// src/report-html/index.ts
+var GAUGE_R = 54;
+var GAUGE_C = Math.round(2 * Math.PI * GAUGE_R);
+var CATEGORY_DESCRIPTIONS = {
+  layout: "Auto Layout, responsive constraints, nesting depth, absolute positioning",
+  token: "Design token binding for colors, fonts, shadows, spacing grid",
+  component: "Component reuse, detached instances, variant coverage",
+  naming: "Semantic layer names, naming conventions, default names",
+  "ai-readability": "Structure clarity for AI code generation, z-index, empty frames",
+  "handoff-risk": "Hardcoded values, text truncation, image placeholders, dev status"
+};
+var SEVERITY_ORDER = ["blocking", "risk", "missing-info", "suggestion"];
+function gaugeColor(pct) {
+  if (pct >= 75) return "#22c55e";
+  if (pct >= 50) return "#f59e0b";
+  return "#ef4444";
+}
+function severityBadge(sev) {
+  const map = {
+    blocking: "bg-red-500/10 text-red-600 border-red-500/20",
+    risk: "bg-amber-500/10 text-amber-600 border-amber-500/20",
+    "missing-info": "bg-zinc-500/10 text-zinc-600 border-zinc-500/20",
+    suggestion: "bg-green-500/10 text-green-600 border-green-500/20"
+  };
+  return map[sev];
+}
+function scoreBadgeStyle(pct) {
+  if (pct >= 75) return "bg-green-500/10 text-green-700 border-green-500/20";
+  if (pct >= 50) return "bg-amber-500/10 text-amber-700 border-amber-500/20";
+  return "bg-red-500/10 text-red-700 border-red-500/20";
+}
+function severityDot(sev) {
+  const map = {
+    blocking: "bg-red-500",
+    risk: "bg-amber-500",
+    "missing-info": "bg-zinc-400",
+    suggestion: "bg-green-500"
+  };
+  return map[sev];
+}
+function generateHtmlReport(file, result, scores, options) {
+  const screenshotMap = new Map(
+    (options?.nodeScreenshots ?? []).map((ns) => [ns.nodeId, ns])
+  );
+  const figmaToken = options?.figmaToken;
+  const quickWins = getQuickWins(result.issues, 5);
+  const issuesByCategory = groupIssuesByCategory(result.issues);
+  return `<!DOCTYPE html>
+<html lang="en" class="antialiased">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>CanICode Report \u2014 ${esc(file.name)}</title>
+  <script src="https://cdn.tailwindcss.com"></script>
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+  <script>
+    tailwind.config = {
+      theme: {
+        extend: {
+          fontFamily: { sans: ['Inter', 'ui-sans-serif', 'system-ui', '-apple-system', 'sans-serif'] },
+          colors: {
+            border: 'hsl(240 5.9% 90%)',
+            ring: 'hsl(240 5.9% 10%)',
+            background: 'hsl(0 0% 100%)',
+            foreground: 'hsl(240 10% 3.9%)',
+            muted: { DEFAULT: 'hsl(240 4.8% 95.9%)', foreground: 'hsl(240 3.8% 46.1%)' },
+            card: { DEFAULT: 'hsl(0 0% 100%)', foreground: 'hsl(240 10% 3.9%)' },
+          },
+          borderRadius: { lg: '0.5rem', md: 'calc(0.5rem - 2px)', sm: 'calc(0.5rem - 4px)' },
+        }
+      }
+    }
+  </script>
+  <style>
+    details summary::-webkit-details-marker { display: none; }
+    details summary::marker { content: ""; }
+    details summary { list-style: none; }
+    .gauge-fill { transition: stroke-dashoffset 0.8s cubic-bezier(0.4,0,0.2,1); }
+    @media print {
+      .no-print { display: none !important; }
+      .topbar-print { position: static !important; background: white !important; color: hsl(240 10% 3.9%) !important; }
+    }
+  </style>
+</head>
+<body class="bg-muted font-sans text-foreground min-h-screen">
+
+  <!-- Top Bar -->
+  <header class="topbar-print sticky top-0 z-50 bg-zinc-950 text-white border-b border-zinc-800">
+    <div class="max-w-[960px] mx-auto px-6 py-3 flex items-center gap-4">
+      <span class="font-semibold text-sm tracking-tight">CanICode</span>
+      <span class="text-zinc-400 text-sm truncate">${esc(file.name)}</span>
+      <span class="ml-auto text-zinc-500 text-xs no-print">${(/* @__PURE__ */ new Date()).toLocaleDateString()}</span>
+    </div>
+  </header>
+
+  <main class="max-w-[960px] mx-auto px-6 pb-16">
+
+    <!-- Overall Score -->
+    <section class="flex flex-col items-center pt-12 pb-6">
+      ${renderGaugeSvg(scores.overall.percentage, 200, 10, scores.overall.grade)}
+      <div class="mt-3 text-center">
+        <span class="text-lg font-semibold">${scores.overall.percentage}</span>
+        <span class="text-muted-foreground text-sm ml-1">/ 100</span>
+      </div>
+      <p class="text-muted-foreground text-sm mt-1">Overall Score</p>
+    </section>
+
+    <!-- Category Gauges -->
+    <section class="bg-card border border-border rounded-lg shadow-sm p-6 mb-6">
+      <div class="grid grid-cols-3 sm:grid-cols-6 gap-4">
+${CATEGORIES.map((cat) => {
+    const cs = scores.byCategory[cat];
+    const desc = CATEGORY_DESCRIPTIONS[cat];
+    return `        <div class="flex flex-col items-center group relative">
+          ${renderGaugeSvg(cs.percentage, 100, 7)}
+          <span class="text-xs font-medium mt-2.5 text-center leading-tight">${CATEGORY_LABELS[cat]}</span>
+          <span class="text-[11px] text-muted-foreground">${cs.issueCount} issues</span>
+          <div class="absolute bottom-full mb-2 left-1/2 -translate-x-1/2 hidden group-hover:block bg-zinc-900 text-white text-xs px-3 py-2 rounded-md whitespace-nowrap z-10 shadow-lg pointer-events-none">
+            ${esc(desc)}
+            <div class="absolute top-full left-1/2 -translate-x-1/2 border-4 border-transparent border-t-zinc-900"></div>
+          </div>
+        </div>`;
+  }).join("\n")}
+      </div>
+    </section>
+
+    <!-- Issue Summary -->
+    <section class="bg-card border border-border rounded-lg shadow-sm p-4 mb-6">
+      <div class="flex flex-wrap items-center justify-center gap-6">
+        ${renderSummaryDot("bg-red-500", scores.summary.blocking, "Blocking")}
+        ${renderSummaryDot("bg-amber-500", scores.summary.risk, "Risk")}
+        ${renderSummaryDot("bg-zinc-400", scores.summary.missingInfo, "Missing Info")}
+        ${renderSummaryDot("bg-green-500", scores.summary.suggestion, "Suggestion")}
+        <div class="border-l border-border pl-6 flex items-center gap-2">
+          <span class="text-xl font-bold tracking-tight">${scores.summary.totalIssues}</span>
+          <span class="text-sm text-muted-foreground">Total</span>
+        </div>
+      </div>
+    </section>
+
+${quickWins.length > 0 ? renderOpportunities(quickWins, file.fileKey) : ""}
+
+    <!-- Categories -->
+    <div class="space-y-3">
+${CATEGORIES.map((cat) => renderCategory(cat, scores, issuesByCategory.get(cat) ?? [], file.fileKey, screenshotMap, figmaToken)).join("\n")}
+    </div>
+
+    <!-- Footer -->
+    <footer class="mt-12 pt-6 border-t border-border text-center">
+      <p class="text-sm text-muted-foreground">Generated by <span class="font-semibold text-foreground">CanICode</span></p>
+      <p class="text-xs text-muted-foreground/60 mt-1">${(/* @__PURE__ */ new Date()).toLocaleString()} \xB7 ${result.nodeCount} nodes \xB7 Max depth ${result.maxDepth}</p>
+    </footer>
+
+  </main>
+
+${figmaToken ? `  <script>
+    const FIGMA_TOKEN = '${figmaToken}';
+    async function postComment(btn) {
+      const fileKey = btn.dataset.fileKey;
+      const nodeId = btn.dataset.nodeId.replace(/-/g, ':');
+      const rule = btn.dataset.rule;
+      const message = btn.dataset.message;
+      const path = btn.dataset.path;
+      const fix = btn.dataset.fix;
+      const why = btn.dataset.why;
+      const impact = btn.dataset.impact;
+
+      const commentBody = '[CanICode] ' + rule + '\\n\\nFix: ' + fix + '\\nWhy: ' + why + '\\nImpact: ' + impact + '\\n\\n' + message + '\\nNode: ' + path;
+
+      btn.disabled = true;
+      btn.textContent = 'Sending...';
+
+      try {
+        const res = await fetch('https://api.figma.com/v1/files/' + fileKey + '/comments', {
+          method: 'POST',
+          headers: { 'X-FIGMA-TOKEN': FIGMA_TOKEN, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ message: commentBody, client_meta: { node_id: nodeId } }),
+        });
+        if (!res.ok) throw new Error(await res.text());
+        btn.textContent = 'Sent \\u2713';
+        btn.classList.remove('hover:bg-muted');
+        btn.classList.add('text-green-600', 'border-green-500/30');
+      } catch (e) {
+        btn.textContent = 'Failed \\u2717';
+        btn.classList.remove('hover:bg-muted');
+        btn.classList.add('text-red-600', 'border-red-500/30');
+        btn.disabled = false;
+        console.error('Failed to post Figma comment:', e);
+      }
+    }
+  </script>` : ""}
+</body>
+</html>`;
+}
+function renderGaugeSvg(pct, size, strokeW, grade) {
+  const offset = GAUGE_C * (1 - pct / 100);
+  const color = gaugeColor(pct);
+  if (grade) {
+    return `<svg width="${size}" height="${size}" viewBox="0 0 120 120" class="block">
+            <circle cx="60" cy="60" r="${GAUGE_R}" fill="none" stroke-width="${strokeW}" class="stroke-border" />
+            <circle cx="60" cy="60" r="${GAUGE_R}" fill="none" stroke="${color}" stroke-width="${strokeW}" stroke-linecap="round" stroke-dasharray="${GAUGE_C}" stroke-dashoffset="${offset}" transform="rotate(-90 60 60)" class="gauge-fill" />
+            <text x="60" y="60" text-anchor="middle" dominant-baseline="central" fill="currentColor" font-size="52" font-weight="700" class="font-sans">${esc(grade)}</text>
+          </svg>`;
+  }
+  const fontSize = 32;
+  return `<svg width="${size}" height="${size}" viewBox="0 0 120 120" class="block">
+            <circle cx="60" cy="60" r="${GAUGE_R}" fill="none" stroke-width="${strokeW}" class="stroke-border" />
+            <circle cx="60" cy="60" r="${GAUGE_R}" fill="none" stroke="${color}" stroke-width="${strokeW}" stroke-linecap="round" stroke-dasharray="${GAUGE_C}" stroke-dashoffset="${offset}" transform="rotate(-90 60 60)" class="gauge-fill" />
+            <text x="60" y="62" text-anchor="middle" dominant-baseline="central" fill="currentColor" font-size="${fontSize}" font-weight="700" class="font-sans">${pct}</text>
+          </svg>`;
+}
+function renderSummaryDot(dotClass, count, label) {
+  return `<div class="flex items-center gap-2">
+          <span class="w-2.5 h-2.5 rounded-full ${dotClass}"></span>
+          <span class="text-lg font-bold tracking-tight">${count}</span>
+          <span class="text-sm text-muted-foreground">${label}</span>
+        </div>`;
+}
+function renderOpportunities(issues, fileKey) {
+  const maxAbs = issues.reduce((m, i) => Math.max(m, Math.abs(i.calculatedScore)), 1);
+  return `
+    <!-- Opportunities -->
+    <section class="bg-card border border-border rounded-lg shadow-sm mb-6 overflow-hidden">
+      <div class="px-6 py-4 border-b border-border">
+        <h2 class="text-sm font-semibold flex items-center gap-2">
+          <span class="w-2 h-2 rounded-full bg-red-500"></span>
+          Opportunities
+        </h2>
+        <p class="text-xs text-muted-foreground mt-1">Top blocking issues \u2014 fix these first for the biggest improvement.</p>
+      </div>
+      <div class="divide-y divide-border">
+${issues.map((issue) => {
+    const def = issue.rule.definition;
+    const link = buildFigmaDeepLink(fileKey, issue.violation.nodeId);
+    const barW = Math.round(Math.abs(issue.calculatedScore) / maxAbs * 100);
+    return `        <div class="px-6 py-3 flex items-center gap-4 hover:bg-muted/50 transition-colors">
+          <div class="flex-1 min-w-0">
+            <div class="text-sm font-medium truncate">${esc(def.name)}</div>
+            <div class="text-xs text-muted-foreground truncate mt-0.5">${esc(issue.violation.message)}</div>
+          </div>
+          <div class="w-32 flex items-center gap-2 shrink-0">
+            <div class="flex-1 h-1.5 bg-muted rounded-full overflow-hidden">
+              <div class="h-full bg-red-500 rounded-full" style="width:${barW}%"></div>
+            </div>
+            <span class="text-xs font-medium text-red-600 w-12 text-right">${issue.calculatedScore}</span>
+          </div>
+          <a href="${link}" target="_blank" rel="noopener" class="text-xs text-muted-foreground hover:text-foreground shrink-0 no-print">Figma \u2192</a>
+        </div>`;
+  }).join("\n")}
+      </div>
+    </section>`;
+}
+function renderCategory(cat, scores, issues, fileKey, screenshotMap, figmaToken) {
+  const cs = scores.byCategory[cat];
+  const hasProblems = issues.some((i) => i.config.severity === "blocking" || i.config.severity === "risk");
+  const bySeverity = /* @__PURE__ */ new Map();
+  for (const sev of SEVERITY_ORDER) bySeverity.set(sev, []);
+  for (const issue of issues) bySeverity.get(issue.config.severity)?.push(issue);
+  return `
+      <details class="bg-card border border-border rounded-lg shadow-sm overflow-hidden group"${hasProblems ? " open" : ""}>
+        <summary class="px-5 py-3.5 flex items-center gap-3 cursor-pointer hover:bg-muted/50 transition-colors select-none">
+          <span class="inline-flex items-center justify-center w-10 h-6 rounded-md text-xs font-bold border ${scoreBadgeStyle(cs.percentage)}">${cs.percentage}</span>
+          <div class="flex-1 min-w-0">
+            <div class="text-sm font-semibold">${CATEGORY_LABELS[cat]}</div>
+            <div class="text-xs text-muted-foreground">${esc(CATEGORY_DESCRIPTIONS[cat])}</div>
+          </div>
+          <span class="text-xs text-muted-foreground">${cs.issueCount} issues</span>
+          <svg class="w-4 h-4 text-muted-foreground transition-transform group-open:rotate-180 shrink-0 no-print" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path d="M19 9l-7 7-7-7"/></svg>
+        </summary>
+        <div class="border-t border-border">
+${issues.length === 0 ? '          <div class="px-5 py-4 text-sm text-green-600 font-medium">No issues found</div>' : SEVERITY_ORDER.filter((sev) => (bySeverity.get(sev)?.length ?? 0) > 0).map((sev) => renderSeverityGroup(sev, bySeverity.get(sev) ?? [], fileKey, screenshotMap, figmaToken)).join("\n")}
+        </div>
+      </details>`;
+}
+function renderSeverityGroup(sev, issues, fileKey, screenshotMap, figmaToken) {
+  return `          <div class="px-5 py-3">
+            <div class="flex items-center gap-2 mb-2">
+              <span class="w-2 h-2 rounded-full ${severityDot(sev)}"></span>
+              <span class="text-xs font-semibold uppercase tracking-wider">${SEVERITY_LABELS[sev]}</span>
+              <span class="text-xs text-muted-foreground ml-auto">${issues.length}</span>
+            </div>
+            <div class="space-y-1">
+${issues.map((issue) => renderIssueRow(issue, fileKey, screenshotMap, figmaToken)).join("\n")}
+            </div>
+          </div>`;
+}
+function renderIssueRow(issue, fileKey, screenshotMap, figmaToken) {
+  const sev = issue.config.severity;
+  const def = issue.rule.definition;
+  const link = buildFigmaDeepLink(fileKey, issue.violation.nodeId);
+  const screenshot = screenshotMap.get(issue.violation.nodeId);
+  const screenshotHtml = screenshot ? `<div class="mt-3"><a href="${link}" target="_blank" rel="noopener"><img src="data:image/png;base64,${screenshot.screenshotBase64}" alt="${esc(screenshot.nodePath)}" class="max-w-[240px] border border-border rounded-md"></a></div>` : "";
+  return `              <details class="border border-border rounded-md overflow-hidden">
+                <summary class="flex items-center gap-2.5 px-3 py-2 text-sm cursor-pointer hover:bg-muted/50 transition-colors">
+                  <span class="w-1.5 h-1.5 rounded-full ${severityDot(sev)} shrink-0"></span>
+                  <span class="font-medium shrink-0">${esc(def.name)}</span>
+                  <span class="text-muted-foreground truncate text-xs flex-1">${esc(issue.violation.message)}</span>
+                  <span class="inline-flex items-center px-1.5 py-0.5 text-[10px] font-medium rounded border ${severityBadge(sev)} shrink-0">${issue.calculatedScore}</span>
+                </summary>
+                <div class="px-3 py-3 bg-muted/30 border-t border-border text-sm space-y-2">
+                  <div class="font-mono text-xs text-muted-foreground break-all">${esc(issue.violation.nodePath)}</div>
+                  <div class="text-muted-foreground leading-relaxed space-y-1">
+                    <p><span class="font-medium text-foreground">Why:</span> ${esc(def.why)}</p>
+                    <p><span class="font-medium text-foreground">Impact:</span> ${esc(def.impact)}</p>
+                    <p><span class="font-medium text-foreground">Fix:</span> ${esc(def.fix)}</p>
+                  </div>${screenshotHtml}
+                  <div class="flex items-center gap-2 mt-1 no-print">
+                    <a href="${link}" target="_blank" rel="noopener" class="inline-flex items-center gap-1 px-2.5 py-1 text-xs font-medium border border-border rounded-md hover:bg-muted transition-colors">Open in Figma <span>\u2192</span></a>${figmaToken ? `
+                    <button onclick="postComment(this)" data-file-key="${esc(fileKey)}" data-node-id="${esc(issue.violation.nodeId)}" data-rule="${esc(def.name)}" data-message="${esc(issue.violation.message)}" data-path="${esc(issue.violation.nodePath)}" data-fix="${esc(def.fix)}" data-why="${esc(def.why)}" data-impact="${esc(def.impact)}" class="inline-flex items-center gap-1 px-2.5 py-1 text-xs font-medium border border-border rounded-md hover:bg-muted transition-colors cursor-pointer">Comment on Figma</button>` : ""}
+                  </div>
+                </div>
+              </details>`;
+}
+function getQuickWins(issues, limit) {
+  return issues.filter((issue) => issue.config.severity === "blocking").sort((a, b) => a.calculatedScore - b.calculatedScore).slice(0, limit);
+}
+function groupIssuesByCategory(issues) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const category of CATEGORIES) grouped.set(category, []);
+  for (const issue of issues) grouped.get(issue.rule.definition.category).push(issue);
+  return grouped;
+}
+function esc(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+var RuleOverrideSchema = z.object({
+  score: z.number().int().max(0).optional(),
+  severity: SeveritySchema.optional(),
+  enabled: z.boolean().optional()
+});
+var ConfigFileSchema = z.object({
+  excludeNodeTypes: z.array(z.string()).optional(),
+  excludeNodeNames: z.array(z.string()).optional(),
+  gridBase: z.number().int().positive().optional(),
+  colorTolerance: z.number().int().positive().optional(),
+  rules: z.record(z.string(), RuleOverrideSchema).optional()
+});
+async function loadConfigFile(filePath) {
+  const absPath = resolve(filePath);
+  const raw = await readFile(absPath, "utf-8");
+  const parsed = JSON.parse(raw);
+  return ConfigFileSchema.parse(parsed);
+}
+function mergeConfigs(base, overrides) {
+  const merged = { ...base };
+  if (overrides.gridBase !== void 0) {
+    for (const [id, config2] of Object.entries(merged)) {
+      if (config2.options && "gridBase" in config2.options) {
+        merged[id] = {
+          ...config2,
+          options: { ...config2.options, gridBase: overrides.gridBase }
+        };
+      }
+    }
+  }
+  if (overrides.colorTolerance !== void 0) {
+    for (const [id, config2] of Object.entries(merged)) {
+      if (config2.options && "tolerance" in config2.options) {
+        merged[id] = {
+          ...config2,
+          options: { ...config2.options, tolerance: overrides.colorTolerance }
+        };
+      }
+    }
+  }
+  if (overrides.rules) {
+    for (const [ruleId, override] of Object.entries(overrides.rules)) {
+      const existing = merged[ruleId];
+      if (existing) {
+        merged[ruleId] = {
+          ...existing,
+          ...override.score !== void 0 && { score: override.score },
+          ...override.severity !== void 0 && { severity: override.severity },
+          ...override.enabled !== void 0 && { enabled: override.enabled }
+        };
+      }
+    }
+  }
+  return merged;
+}
+var CustomRuleSchema = z.object({
+  id: z.string(),
+  category: CategorySchema,
+  severity: SeveritySchema,
+  score: z.number().int().max(0),
+  prompt: z.string(),
+  why: z.string(),
+  impact: z.string(),
+  fix: z.string()
+});
+var CustomRulesFileSchema = z.array(CustomRuleSchema);
+
+// src/rules/custom/custom-rule-loader.ts
+async function loadCustomRules(filePath) {
+  const absPath = resolve(filePath);
+  const raw = await readFile(absPath, "utf-8");
+  const parsed = JSON.parse(raw);
+  const customRules = CustomRulesFileSchema.parse(parsed);
+  const rules = [];
+  const configs = {};
+  for (const cr of customRules) {
+    rules.push(toRule(cr));
+    configs[cr.id] = {
+      severity: cr.severity,
+      score: cr.score,
+      enabled: true
+    };
+  }
+  return { rules, configs };
+}
+function toRule(cr) {
+  return {
+    definition: {
+      id: cr.id,
+      name: cr.id.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
+      category: cr.category,
+      why: cr.why,
+      impact: cr.impact,
+      fix: cr.fix
+    },
+    check: createPromptBasedCheck()
+  };
+}
+function createPromptBasedCheck(_cr) {
+  return (node, _context) => {
+    if (node.type === "DOCUMENT" || node.type === "CANVAS") return null;
+    return null;
+  };
+}
+
+// src/rules/layout/index.ts
+function isContainerNode(node) {
+  return node.type === "FRAME" || node.type === "GROUP" || node.type === "COMPONENT";
+}
+function hasAutoLayout(node) {
+  return node.layoutMode !== void 0 && node.layoutMode !== "NONE";
+}
+function hasTextContent(node) {
+  return node.type === "TEXT" || (node.children?.some((c) => c.type === "TEXT") ?? false);
+}
+var noAutoLayoutDef = {
+  id: "no-auto-layout",
+  name: "No Auto Layout",
+  category: "layout",
+  why: "Frames without Auto Layout require manual positioning for every element",
+  impact: "Layout breaks on content changes, harder to maintain and scale",
+  fix: "Apply Auto Layout to the frame with appropriate direction and spacing"
+};
+var noAutoLayoutCheck = (node, context) => {
+  if (node.type !== "FRAME") return null;
+  if (hasAutoLayout(node)) return null;
+  if (!node.children || node.children.length === 0) return null;
+  return {
+    ruleId: noAutoLayoutDef.id,
+    nodeId: node.id,
+    nodePath: context.path.join(" > "),
+    message: `Frame "${node.name}" has no Auto Layout`
+  };
+};
+defineRule({
+  definition: noAutoLayoutDef,
+  check: noAutoLayoutCheck
+});
+var absolutePositionInAutoLayoutDef = {
+  id: "absolute-position-in-auto-layout",
+  name: "Absolute Position in Auto Layout",
+  category: "layout",
+  why: "Absolute positioning inside Auto Layout breaks the automatic flow",
+  impact: "Element will not respond to sibling changes, may overlap unexpectedly",
+  fix: "Remove absolute positioning or use proper Auto Layout alignment"
+};
+var INTENTIONAL_ABSOLUTE_PATTERNS = /^(badge|close|dismiss|overlay|float|fab|dot|indicator|corner|decoration|tag|status|notification|x|icon[-_ ]?(close|dismiss|x)|btn[-_ ]?(close|dismiss))/i;
+function isSmallRelativeToParent(node, parent) {
+  const nodeBB = node.absoluteBoundingBox;
+  const parentBB = parent.absoluteBoundingBox;
+  if (!nodeBB || !parentBB) return false;
+  if (parentBB.width === 0 || parentBB.height === 0) return false;
+  const widthRatio = nodeBB.width / parentBB.width;
+  const heightRatio = nodeBB.height / parentBB.height;
+  return widthRatio < 0.25 && heightRatio < 0.25;
+}
+var absolutePositionInAutoLayoutCheck = (node, context) => {
+  if (!context.parent) return null;
+  if (!hasAutoLayout(context.parent)) return null;
+  if (node.layoutPositioning !== "ABSOLUTE") return null;
+  if (INTENTIONAL_ABSOLUTE_PATTERNS.test(node.name)) return null;
+  if (isSmallRelativeToParent(node, context.parent)) return null;
+  if (context.parent.type === "COMPONENT") return null;
+  return {
+    ruleId: absolutePositionInAutoLayoutDef.id,
+    nodeId: node.id,
+    nodePath: context.path.join(" > "),
+    message: `"${node.name}" uses absolute positioning inside Auto Layout parent "${context.parent.name}". If intentional (badge, overlay, close button), rename to badge-*, overlay-*, close-* to suppress this warning.`
+  };
+};
+defineRule({
+  definition: absolutePositionInAutoLayoutDef,
+  check: absolutePositionInAutoLayoutCheck
+});
+var fixedWidthInResponsiveContextDef = {
+  id: "fixed-width-in-responsive-context",
+  name: "Fixed Width in Responsive Context",
+  category: "layout",
+  why: "Fixed width inside Auto Layout prevents responsive behavior",
+  impact: "Content will not adapt to container size changes",
+  fix: "Use 'Fill' or 'Hug' instead of fixed width"
+};
+var fixedWidthInResponsiveContextCheck = (node, context) => {
+  if (!context.parent) return null;
+  if (!hasAutoLayout(context.parent)) return null;
+  if (!isContainerNode(node)) return null;
+  if (node.layoutAlign === "STRETCH") return null;
+  const bbox = node.absoluteBoundingBox;
+  if (!bbox) return null;
+  if (node.layoutAlign !== "INHERIT") return null;
+  return {
+    ruleId: fixedWidthInResponsiveContextDef.id,
+    nodeId: node.id,
+    nodePath: context.path.join(" > "),
+    message: `"${node.name}" has fixed width inside Auto Layout`
+  };
+};
+defineRule({
+  definition: fixedWidthInResponsiveContextDef,
+  check: fixedWidthInResponsiveContextCheck
+});
+var missingResponsiveBehaviorDef = {
+  id: "missing-responsive-behavior",
+  name: "Missing Responsive Behavior",
+  category: "layout",
+  why: "Elements without constraints won't adapt to different screen sizes",
+  impact: "Layout will break or look wrong on different devices",
+  fix: "Set appropriate constraints (left/right, top/bottom, scale, etc.)"
+};
+var missingResponsiveBehaviorCheck = (node, context) => {
+  if (!isContainerNode(node)) return null;
+  if (context.parent && hasAutoLayout(context.parent)) return null;
+  if (context.depth < 2) return null;
+  if (!hasAutoLayout(node) && !node.layoutAlign) {
+    return {
+      ruleId: missingResponsiveBehaviorDef.id,
+      nodeId: node.id,
+      nodePath: context.path.join(" > "),
+      message: `"${node.name}" has no responsive behavior configured`
+    };
+  }
+  return null;
+};
+defineRule({
+  definition: missingResponsiveBehaviorDef,
+  check: missingResponsiveBehaviorCheck
+});
+var groupUsageDef = {
+  id: "group-usage",
+  name: "Group Usage",
+  category: "layout",
+  why: "Groups don't support Auto Layout and have limited layout control",
+  impact: "Harder to maintain consistent spacing and alignment",
+  fix: "Convert Group to Frame and apply Auto Layout"
+};
+var groupUsageCheck = (node, context) => {
+  if (node.type !== "GROUP") return null;
+  return {
+    ruleId: groupUsageDef.id,
+    nodeId: node.id,
+    nodePath: context.path.join(" > "),
+    message: `"${node.name}" is a Group - consider converting to Frame with Auto Layout`
+  };
+};
+defineRule({
+  definition: groupUsageDef,
+  check: groupUsageCheck
+});
+var fixedSizeInAutoLayoutDef = {
+  id: "fixed-size-in-auto-layout",
+  name: "Fixed Size in Auto Layout",
+  category: "layout",
+  why: "Fixed sizes inside Auto Layout limit flexibility",
+  impact: "Element won't adapt to content or container changes",
+  fix: "Consider using 'Hug' for content-driven sizing"
+};
+var fixedSizeInAutoLayoutCheck = (node, context) => {
+  if (!context.parent) return null;
+  if (!hasAutoLayout(context.parent)) return null;
+  if (!isContainerNode(node)) return null;
+  if (!node.absoluteBoundingBox) return null;
+  const { width, height } = node.absoluteBoundingBox;
+  if (width <= 48 && height <= 48) return null;
+  return null;
+};
+defineRule({
+  definition: fixedSizeInAutoLayoutDef,
+  check: fixedSizeInAutoLayoutCheck
+});
+var missingMinWidthDef = {
+  id: "missing-min-width",
+  name: "Missing Min Width",
+  category: "layout",
+  why: "Without min-width, containers can collapse to unusable sizes",
+  impact: "Text truncation or layout collapse on narrow screens",
+  fix: "Set a minimum width constraint on the container"
+};
+var missingMinWidthCheck = (node, context) => {
+  if (!isContainerNode(node) && !hasTextContent(node)) return null;
+  if (node.absoluteBoundingBox) {
+    const { width, height } = node.absoluteBoundingBox;
+    if (width <= 48 && height <= 24) return null;
+  }
+  if (!context.parent || !hasAutoLayout(context.parent)) return null;
+  return null;
+};
+defineRule({
+  definition: missingMinWidthDef,
+  check: missingMinWidthCheck
+});
+var missingMaxWidthDef = {
+  id: "missing-max-width",
+  name: "Missing Max Width",
+  category: "layout",
+  why: "Without max-width, content can stretch too wide on large screens",
+  impact: "Poor readability and layout on wide screens",
+  fix: "Set a maximum width constraint, especially for text containers"
+};
+var missingMaxWidthCheck = (node, _context) => {
+  if (!isContainerNode(node) && !hasTextContent(node)) return null;
+  if (node.absoluteBoundingBox) {
+    const { width } = node.absoluteBoundingBox;
+    if (width <= 200) return null;
+  }
+  return null;
+};
+defineRule({
+  definition: missingMaxWidthDef,
+  check: missingMaxWidthCheck
+});
+var deepNestingDef = {
+  id: "deep-nesting",
+  name: "Deep Nesting",
+  category: "layout",
+  why: "Deep nesting makes the structure hard to understand and maintain",
+  impact: "Increases complexity, harder to debug layout issues",
+  fix: "Flatten the structure by removing unnecessary wrapper frames"
+};
+var deepNestingCheck = (node, context, options) => {
+  const maxDepth = options?.["maxDepth"] ?? getRuleOption("deep-nesting", "maxDepth", 5);
+  if (context.depth < maxDepth) return null;
+  if (!isContainerNode(node)) return null;
+  return {
+    ruleId: deepNestingDef.id,
+    nodeId: node.id,
+    nodePath: context.path.join(" > "),
+    message: `"${node.name}" is nested ${context.depth} levels deep (max: ${maxDepth})`
+  };
+};
+defineRule({
+  definition: deepNestingDef,
+  check: deepNestingCheck
+});
+var overflowHiddenAbuseDef = {
+  id: "overflow-hidden-abuse",
+  name: "Overflow Hidden Abuse",
+  category: "layout",
+  why: "Using clip content to hide layout problems masks underlying issues",
+  impact: "Content may be unintentionally cut off, problems harder to diagnose",
+  fix: "Fix the underlying layout issue instead of hiding overflow"
+};
+var overflowHiddenAbuseCheck = (_node, _context) => {
+  return null;
+};
+defineRule({
+  definition: overflowHiddenAbuseDef,
+  check: overflowHiddenAbuseCheck
+});
+var inconsistentSiblingLayoutDirectionDef = {
+  id: "inconsistent-sibling-layout-direction",
+  name: "Inconsistent Sibling Layout Direction",
+  category: "layout",
+  why: "Sibling containers with mixed layout directions without clear reason create confusion",
+  impact: "Harder to understand and maintain the design structure",
+  fix: "Use consistent layout direction for similar sibling elements"
+};
+var inconsistentSiblingLayoutDirectionCheck = (node, context) => {
+  if (!isContainerNode(node)) return null;
+  if (!context.siblings || context.siblings.length < 2) return null;
+  const siblingContainers = context.siblings.filter(
+    (s) => isContainerNode(s) && s.id !== node.id
+  );
+  if (siblingContainers.length === 0) return null;
+  const myDirection = node.layoutMode;
+  if (!myDirection || myDirection === "NONE") return null;
+  const siblingDirections = siblingContainers.map((s) => s.layoutMode).filter((d) => d && d !== "NONE");
+  if (siblingDirections.length === 0) return null;
+  const allSameSiblingDirection = siblingDirections.every(
+    (d) => d === siblingDirections[0]
+  );
+  if (allSameSiblingDirection && siblingDirections[0] !== myDirection) {
+    if (context.parent?.layoutMode === "HORIZONTAL" && myDirection === "VERTICAL") {
+      return null;
+    }
+    return {
+      ruleId: inconsistentSiblingLayoutDirectionDef.id,
+      nodeId: node.id,
+      nodePath: context.path.join(" > "),
+      message: `"${node.name}" has ${myDirection} layout while siblings use ${siblingDirections[0]}`
+    };
+  }
+  return null;
+};
+defineRule({
+  definition: inconsistentSiblingLayoutDirectionDef,
+  check: inconsistentSiblingLayoutDirectionCheck
+});
+
+// src/rules/token/index.ts
+function hasStyleReference(node, styleType) {
+  return node.styles !== void 0 && styleType in node.styles;
+}
+function hasBoundVariable(node, key) {
+  return node.boundVariables !== void 0 && key in node.boundVariables;
+}
+function isOnGrid(value, gridBase) {
+  return value % gridBase === 0;
+}
+var rawColorDef = {
+  id: "raw-color",
+  name: "Raw Color",
+  category: "token",
+  why: "Raw hex colors are not connected to the design system",
+  impact: "Color changes require manual updates across the entire design",
+  fix: "Use a color style or variable instead of raw hex values"
+};
+var rawColorCheck = (node, context) => {
+  if (!node.fills || !Array.isArray(node.fills)) return null;
+  if (node.fills.length === 0) return null;
+  if (hasStyleReference(node, "fill")) return null;
+  if (hasBoundVariable(node, "fills")) return null;
+  for (const fill of node.fills) {
+    const fillObj = fill;
+    if (fillObj["type"] === "SOLID" && fillObj["color"]) {
+      return {
+        ruleId: rawColorDef.id,
+        nodeId: node.id,
+        nodePath: context.path.join(" > "),
+        message: `"${node.name}" uses raw color without style or variable`
+      };
+    }
+  }
+  return null;
+};
+defineRule({
+  definition: rawColorDef,
+  check: rawColorCheck
+});
+var rawFontDef = {
+  id: "raw-font",
+  name: "Raw Font",
+  category: "token",
+  why: "Text without text styles is disconnected from the type system",
+  impact: "Typography changes require manual updates across the design",
+  fix: "Apply a text style to maintain consistency"
+};
+var rawFontCheck = (node, context) => {
+  if (node.type !== "TEXT") return null;
+  if (hasStyleReference(node, "text")) return null;
+  if (hasBoundVariable(node, "fontFamily") || hasBoundVariable(node, "fontSize")) {
+    return null;
+  }
+  return {
+    ruleId: rawFontDef.id,
+    nodeId: node.id,
+    nodePath: context.path.join(" > "),
+    message: `"${node.name}" has no text style applied`
+  };
+};
+defineRule({
+  definition: rawFontDef,
+  check: rawFontCheck
+});
+var inconsistentSpacingDef = {
+  id: "inconsistent-spacing",
+  name: "Inconsistent Spacing",
+  category: "token",
+  why: "Spacing values outside the grid system break visual consistency",
+  impact: "Inconsistent visual rhythm and harder to maintain",
+  fix: "Use spacing values from the design system grid (e.g., 8pt increments)"
+};
+var inconsistentSpacingCheck = (node, context, options) => {
+  const gridBase = options?.["gridBase"] ?? getRuleOption("inconsistent-spacing", "gridBase", 8);
+  const paddings = [
+    node.paddingLeft,
+    node.paddingRight,
+    node.paddingTop,
+    node.paddingBottom
+  ].filter((p) => p !== void 0 && p > 0);
+  for (const padding of paddings) {
+    if (!isOnGrid(padding, gridBase)) {
+      return {
+        ruleId: inconsistentSpacingDef.id,
+        nodeId: node.id,
+        nodePath: context.path.join(" > "),
+        message: `"${node.name}" has padding ${padding}px not on ${gridBase}pt grid`
+      };
+    }
+  }
+  if (node.itemSpacing !== void 0 && node.itemSpacing > 0) {
+    if (!isOnGrid(node.itemSpacing, gridBase)) {
+      return {
+        ruleId: inconsistentSpacingDef.id,
+        nodeId: node.id,
+        nodePath: context.path.join(" > "),
+        message: `"${node.name}" has item spacing ${node.itemSpacing}px not on ${gridBase}pt grid`
+      };
+    }
+  }
+  return null;
+};
+defineRule({
+  definition: inconsistentSpacingDef,
+  check: inconsistentSpacingCheck
+});
+var magicNumberSpacingDef = {
+  id: "magic-number-spacing",
+  name: "Magic Number Spacing",
+  category: "token",
+  why: "Arbitrary spacing values make the system harder to understand",
+  impact: "Unpredictable spacing, harder to create consistent layouts",
+  fix: "Round spacing to the nearest grid value or use spacing tokens"
+};
+var magicNumberSpacingCheck = (node, context, options) => {
+  const gridBase = options?.["gridBase"] ?? getRuleOption("magic-number-spacing", "gridBase", 8);
+  const allSpacings = [
+    node.paddingLeft,
+    node.paddingRight,
+    node.paddingTop,
+    node.paddingBottom,
+    node.itemSpacing
+  ].filter((s) => s !== void 0 && s > 0);
+  for (const spacing of allSpacings) {
+    const commonValues = [1, 2, 4];
+    if (!isOnGrid(spacing, gridBase) && !commonValues.includes(spacing)) {
+      if (spacing % 2 !== 0 && spacing > 4) {
+        return {
+          ruleId: magicNumberSpacingDef.id,
+          nodeId: node.id,
+          nodePath: context.path.join(" > "),
+          message: `"${node.name}" uses magic number spacing: ${spacing}px`
+        };
+      }
+    }
+  }
+  return null;
+};
+defineRule({
+  definition: magicNumberSpacingDef,
+  check: magicNumberSpacingCheck
+});
+var rawShadowDef = {
+  id: "raw-shadow",
+  name: "Raw Shadow",
+  category: "token",
+  why: "Shadow effects without styles are disconnected from the design system",
+  impact: "Shadow changes require manual updates across the design",
+  fix: "Create and apply an effect style for shadows"
+};
+var rawShadowCheck = (node, context) => {
+  if (!node.effects || !Array.isArray(node.effects)) return null;
+  if (node.effects.length === 0) return null;
+  if (hasStyleReference(node, "effect")) return null;
+  for (const effect of node.effects) {
+    const effectObj = effect;
+    if (effectObj["type"] === "DROP_SHADOW" || effectObj["type"] === "INNER_SHADOW") {
+      return {
+        ruleId: rawShadowDef.id,
+        nodeId: node.id,
+        nodePath: context.path.join(" > "),
+        message: `"${node.name}" has shadow effect without effect style`
+      };
+    }
+  }
+  return null;
+};
+defineRule({
+  definition: rawShadowDef,
+  check: rawShadowCheck
+});
+var rawOpacityDef = {
+  id: "raw-opacity",
+  name: "Raw Opacity",
+  category: "token",
+  why: "Hardcoded opacity values are not connected to design tokens",
+  impact: "Opacity changes require manual updates",
+  fix: "Use opacity variables or consider if opacity is truly needed"
+};
+var rawOpacityCheck = (node, _context) => {
+  if (hasBoundVariable(node, "opacity")) return null;
+  return null;
+};
+defineRule({
+  definition: rawOpacityDef,
+  check: rawOpacityCheck
+});
+var multipleFillColorsDef = {
+  id: "multiple-fill-colors",
+  name: "Multiple Fill Colors",
+  category: "token",
+  why: "Similar but slightly different colors indicate inconsistent token usage",
+  impact: "Visual inconsistency and harder to maintain brand colors",
+  fix: "Consolidate to a single color token or style"
+};
+var multipleFillColorsCheck = (_node, _context, _options) => {
+  return null;
+};
+defineRule({
+  definition: multipleFillColorsDef,
+  check: multipleFillColorsCheck
+});
+
+// src/rules/component/index.ts
+function isComponentInstance(node) {
+  return node.type === "INSTANCE";
+}
+function isComponent(node) {
+  return node.type === "COMPONENT" || node.type === "COMPONENT_SET";
+}
+function collectFrameNames(node, names = /* @__PURE__ */ new Map()) {
+  if (node.type === "FRAME" && node.name) {
+    const existing = names.get(node.name) ?? [];
+    existing.push(node.id);
+    names.set(node.name, existing);
+  }
+  if (node.children) {
+    for (const child of node.children) {
+      collectFrameNames(child, names);
+    }
+  }
+  return names;
+}
+var missingComponentDef = {
+  id: "missing-component",
+  name: "Missing Component",
+  category: "component",
+  why: "Repeated identical structures should be componentized",
+  impact: "Changes require manual updates in multiple places",
+  fix: "Create a component from the repeated structure"
+};
+var missingComponentCheck = (node, context, options) => {
+  if (node.type !== "FRAME") return null;
+  const minRepetitions = options?.["minRepetitions"] ?? getRuleOption("missing-component", "minRepetitions", 3);
+  const frameNames = collectFrameNames(context.file.document);
+  const sameNameFrames = frameNames.get(node.name);
+  if (sameNameFrames && sameNameFrames.length >= minRepetitions) {
+    if (sameNameFrames[0] === node.id) {
+      return {
+        ruleId: missingComponentDef.id,
+        nodeId: node.id,
+        nodePath: context.path.join(" > "),
+        message: `"${node.name}" appears ${sameNameFrames.length} times - consider making it a component`
+      };
+    }
+  }
+  return null;
+};
+defineRule({
+  definition: missingComponentDef,
+  check: missingComponentCheck
+});
+var detachedInstanceDef = {
+  id: "detached-instance",
+  name: "Detached Instance",
+  category: "component",
+  why: "Detached instances lose their connection to the source component",
+  impact: "Updates to the component won't propagate to this instance",
+  fix: "Reset the instance or create a new variant if customization is needed"
+};
+var detachedInstanceCheck = (node, context) => {
+  if (node.type !== "FRAME") return null;
+  const components = context.file.components;
+  const nodeName = node.name.toLowerCase();
+  for (const [, component] of Object.entries(components)) {
+    if (nodeName.includes(component.name.toLowerCase())) {
+      return {
+        ruleId: detachedInstanceDef.id,
+        nodeId: node.id,
+        nodePath: context.path.join(" > "),
+        message: `"${node.name}" may be a detached instance of component "${component.name}"`
+      };
+    }
+  }
+  return null;
+};
+defineRule({
+  definition: detachedInstanceDef,
+  check: detachedInstanceCheck
+});
+var nestedInstanceOverrideDef = {
+  id: "nested-instance-override",
+  name: "Nested Instance Override",
+  category: "component",
+  why: "Excessive overrides in instances make components harder to maintain",
+  impact: "Component updates may not work as expected",
+  fix: "Create a variant or new component for significantly different use cases"
+};
+var nestedInstanceOverrideCheck = (node, context) => {
+  if (!isComponentInstance(node)) return null;
+  if (!node.componentProperties) return null;
+  const overrideCount = Object.keys(node.componentProperties).length;
+  if (overrideCount > 5) {
+    return {
+      ruleId: nestedInstanceOverrideDef.id,
+      nodeId: node.id,
+      nodePath: context.path.join(" > "),
+      message: `"${node.name}" has ${overrideCount} property overrides - consider creating a variant`
+    };
+  }
+  return null;
+};
+defineRule({
+  definition: nestedInstanceOverrideDef,
+  check: nestedInstanceOverrideCheck
+});
+var variantNotUsedDef = {
+  id: "variant-not-used",
+  name: "Variant Not Used",
+  category: "component",
+  why: "Using instances but not leveraging variants defeats their purpose",
+  impact: "Manual changes instead of using designed variants",
+  fix: "Use the appropriate variant instead of overriding the default"
+};
+var variantNotUsedCheck = (_node, _context) => {
+  return null;
+};
+defineRule({
+  definition: variantNotUsedDef,
+  check: variantNotUsedCheck
+});
+var componentPropertyUnusedDef = {
+  id: "component-property-unused",
+  name: "Component Property Unused",
+  category: "component",
+  why: "Component properties should be utilized to expose customization",
+  impact: "Hardcoded values that should be configurable",
+  fix: "Connect the value to a component property"
+};
+var componentPropertyUnusedCheck = (node, _context) => {
+  if (!isComponent(node)) return null;
+  if (!node.componentPropertyDefinitions) return null;
+  const definedProps = Object.keys(node.componentPropertyDefinitions);
+  if (definedProps.length === 0) return null;
+  return null;
+};
+defineRule({
+  definition: componentPropertyUnusedDef,
+  check: componentPropertyUnusedCheck
+});
+var singleUseComponentDef = {
+  id: "single-use-component",
+  name: "Single Use Component",
+  category: "component",
+  why: "Components used only once add complexity without reuse benefit",
+  impact: "Unnecessary abstraction increases maintenance overhead",
+  fix: "Consider inlining if this component won't be reused"
+};
+var singleUseComponentCheck = (node, context) => {
+  if (!isComponent(node)) return null;
+  let instanceCount = 0;
+  function countInstances(n) {
+    if (n.type === "INSTANCE" && n.componentId === node.id) {
+      instanceCount++;
+    }
+    if (n.children) {
+      for (const child of n.children) {
+        countInstances(child);
+      }
+    }
+  }
+  countInstances(context.file.document);
+  if (instanceCount === 1) {
+    return {
+      ruleId: singleUseComponentDef.id,
+      nodeId: node.id,
+      nodePath: context.path.join(" > "),
+      message: `Component "${node.name}" is only used once`
+    };
+  }
+  return null;
+};
+defineRule({
+  definition: singleUseComponentDef,
+  check: singleUseComponentCheck
+});
+
+// src/rules/naming/index.ts
+var DEFAULT_NAME_PATTERNS = [
+  /^Frame\s*\d*$/i,
+  /^Group\s*\d*$/i,
+  /^Rectangle\s*\d*$/i,
+  /^Ellipse\s*\d*$/i,
+  /^Vector\s*\d*$/i,
+  /^Line\s*\d*$/i,
+  /^Text\s*\d*$/i,
+  /^Image\s*\d*$/i,
+  /^Component\s*\d*$/i,
+  /^Instance\s*\d*$/i
+];
+var NON_SEMANTIC_NAMES = [
+  "rectangle",
+  "ellipse",
+  "vector",
+  "line",
+  "polygon",
+  "star",
+  "path",
+  "shape",
+  "image",
+  "fill",
+  "stroke"
+];
+function isDefaultName(name) {
+  return DEFAULT_NAME_PATTERNS.some((pattern) => pattern.test(name));
+}
+function isNonSemanticName(name) {
+  const normalized = name.toLowerCase().trim();
+  return NON_SEMANTIC_NAMES.includes(normalized);
+}
+function hasNumericSuffix(name) {
+  return /\s+\d+$/.test(name);
+}
+function detectNamingConvention(name) {
+  if (/^[a-z]+(-[a-z]+)*$/.test(name)) return "kebab-case";
+  if (/^[a-z]+(_[a-z]+)*$/.test(name)) return "snake_case";
+  if (/^[a-z]+([A-Z][a-z]*)*$/.test(name)) return "camelCase";
+  if (/^[A-Z][a-z]+([A-Z][a-z]*)*$/.test(name)) return "PascalCase";
+  if (/^[A-Z]+(_[A-Z]+)*$/.test(name)) return "SCREAMING_SNAKE_CASE";
+  if (/\s/.test(name)) return "Title Case";
+  return null;
+}
+var defaultNameDef = {
+  id: "default-name",
+  name: "Default Name",
+  category: "naming",
+  why: "Default names like 'Frame 123' provide no context about the element's purpose",
+  impact: "Designers and developers cannot understand the structure",
+  fix: "Rename with a descriptive, semantic name (e.g., 'Header', 'ProductCard')"
+};
+var defaultNameCheck = (node, context) => {
+  if (!node.name) return null;
+  if (!isDefaultName(node.name)) return null;
+  return {
+    ruleId: defaultNameDef.id,
+    nodeId: node.id,
+    nodePath: context.path.join(" > "),
+    message: `"${node.name}" is a default name - provide a meaningful name`
+  };
+};
+defineRule({
+  definition: defaultNameDef,
+  check: defaultNameCheck
+});
+var nonSemanticNameDef = {
+  id: "non-semantic-name",
+  name: "Non-Semantic Name",
+  category: "naming",
+  why: "Names like 'Rectangle' describe shape, not purpose",
+  impact: "Structure is hard to understand without context",
+  fix: "Use names that describe what the element represents (e.g., 'Divider', 'Avatar')"
+};
+var nonSemanticNameCheck = (node, context) => {
+  if (!node.name) return null;
+  if (!isNonSemanticName(node.name)) return null;
+  if (!node.children || node.children.length === 0) {
+    const shapeTypes = ["RECTANGLE", "ELLIPSE", "VECTOR", "LINE", "STAR", "REGULAR_POLYGON"];
+    if (shapeTypes.includes(node.type)) return null;
+  }
+  return {
+    ruleId: nonSemanticNameDef.id,
+    nodeId: node.id,
+    nodePath: context.path.join(" > "),
+    message: `"${node.name}" is a non-semantic name - describe its purpose`
+  };
+};
+defineRule({
+  definition: nonSemanticNameDef,
+  check: nonSemanticNameCheck
+});
+var inconsistentNamingConventionDef = {
+  id: "inconsistent-naming-convention",
+  name: "Inconsistent Naming Convention",
+  category: "naming",
+  why: "Mixed naming conventions at the same level create confusion",
+  impact: "Harder to navigate and maintain the design",
+  fix: "Use a consistent naming convention for sibling elements"
+};
+var inconsistentNamingConventionCheck = (node, context) => {
+  if (!context.siblings || context.siblings.length < 2) return null;
+  const conventions = /* @__PURE__ */ new Map();
+  for (const sibling of context.siblings) {
+    if (!sibling.name) continue;
+    const convention = detectNamingConvention(sibling.name);
+    if (convention) {
+      conventions.set(convention, (conventions.get(convention) ?? 0) + 1);
+    }
+  }
+  if (conventions.size < 2) return null;
+  let dominantConvention = "";
+  let maxCount = 0;
+  for (const [convention, count] of conventions) {
+    if (count > maxCount) {
+      maxCount = count;
+      dominantConvention = convention;
+    }
+  }
+  const nodeConvention = detectNamingConvention(node.name);
+  if (nodeConvention && nodeConvention !== dominantConvention && maxCount >= 2) {
+    return {
+      ruleId: inconsistentNamingConventionDef.id,
+      nodeId: node.id,
+      nodePath: context.path.join(" > "),
+      message: `"${node.name}" uses ${nodeConvention} while siblings use ${dominantConvention}`
+    };
+  }
+  return null;
+};
+defineRule({
+  definition: inconsistentNamingConventionDef,
+  check: inconsistentNamingConventionCheck
+});
+var numericSuffixNameDef = {
+  id: "numeric-suffix-name",
+  name: "Numeric Suffix Name",
+  category: "naming",
+  why: "Names with numeric suffixes often indicate copy-paste duplication",
+  impact: "Suggests the element might need componentization",
+  fix: "Remove the suffix or create a component if duplicated"
+};
+var numericSuffixNameCheck = (node, context) => {
+  if (!node.name) return null;
+  if (isDefaultName(node.name)) return null;
+  if (!hasNumericSuffix(node.name)) return null;
+  return {
+    ruleId: numericSuffixNameDef.id,
+    nodeId: node.id,
+    nodePath: context.path.join(" > "),
+    message: `"${node.name}" has a numeric suffix - consider renaming`
+  };
+};
+defineRule({
+  definition: numericSuffixNameDef,
+  check: numericSuffixNameCheck
+});
+var tooLongNameDef = {
+  id: "too-long-name",
+  name: "Too Long Name",
+  category: "naming",
+  why: "Very long names are hard to read and use in code",
+  impact: "Clutters the layer panel and makes selectors unwieldy",
+  fix: "Shorten the name while keeping it descriptive"
+};
+var tooLongNameCheck = (node, context, options) => {
+  if (!node.name) return null;
+  const maxLength = options?.["maxLength"] ?? getRuleOption("too-long-name", "maxLength", 50);
+  if (node.name.length <= maxLength) return null;
+  return {
+    ruleId: tooLongNameDef.id,
+    nodeId: node.id,
+    nodePath: context.path.join(" > "),
+    message: `"${node.name.substring(0, 30)}..." is ${node.name.length} chars (max: ${maxLength})`
+  };
+};
+defineRule({
+  definition: tooLongNameDef,
+  check: tooLongNameCheck
+});
+
+// src/rules/ai-readability/index.ts
+function hasAutoLayout2(node) {
+  return node.layoutMode !== void 0 && node.layoutMode !== "NONE";
+}
+function isContainerNode2(node) {
+  return node.type === "FRAME" || node.type === "GROUP" || node.type === "COMPONENT";
+}
+function hasOverlappingBounds(a, b) {
+  const boxA = a.absoluteBoundingBox;
+  const boxB = b.absoluteBoundingBox;
+  if (!boxA || !boxB) return false;
+  return !(boxA.x + boxA.width <= boxB.x || boxB.x + boxB.width <= boxA.x || boxA.y + boxA.height <= boxB.y || boxB.y + boxB.height <= boxA.y);
+}
+var ambiguousStructureDef = {
+  id: "ambiguous-structure",
+  name: "Ambiguous Structure",
+  category: "ai-readability",
+  why: "Overlapping nodes without Auto Layout create ambiguous visual hierarchy",
+  impact: "AI cannot reliably determine the reading order or structure",
+  fix: "Use Auto Layout to create clear, explicit structure"
+};
+var ambiguousStructureCheck = (node, context) => {
+  if (!isContainerNode2(node)) return null;
+  if (hasAutoLayout2(node)) return null;
+  if (!node.children || node.children.length < 2) return null;
+  for (let i = 0; i < node.children.length; i++) {
+    for (let j = i + 1; j < node.children.length; j++) {
+      const childA = node.children[i];
+      const childB = node.children[j];
+      if (childA && childB && hasOverlappingBounds(childA, childB)) {
+        if (childA.visible !== false && childB.visible !== false) {
+          return {
+            ruleId: ambiguousStructureDef.id,
+            nodeId: node.id,
+            nodePath: context.path.join(" > "),
+            message: `"${node.name}" has overlapping children without Auto Layout`
+          };
+        }
+      }
+    }
+  }
+  return null;
+};
+defineRule({
+  definition: ambiguousStructureDef,
+  check: ambiguousStructureCheck
+});
+var zIndexDependentLayoutDef = {
+  id: "z-index-dependent-layout",
+  name: "Z-Index Dependent Layout",
+  category: "ai-readability",
+  why: "Using overlapping layers to create visual layout is hard to interpret",
+  impact: "Code generation may misinterpret the intended layout",
+  fix: "Restructure using Auto Layout to express the visual relationship explicitly"
+};
+var zIndexDependentLayoutCheck = (node, context) => {
+  if (!isContainerNode2(node)) return null;
+  if (!node.children || node.children.length < 2) return null;
+  let significantOverlapCount = 0;
+  for (let i = 0; i < node.children.length; i++) {
+    for (let j = i + 1; j < node.children.length; j++) {
+      const childA = node.children[i];
+      const childB = node.children[j];
+      if (!childA || !childB) continue;
+      if (childA.visible === false || childB.visible === false) continue;
+      const boxA = childA.absoluteBoundingBox;
+      const boxB = childB.absoluteBoundingBox;
+      if (!boxA || !boxB) continue;
+      if (hasOverlappingBounds(childA, childB)) {
+        const overlapX = Math.min(boxA.x + boxA.width, boxB.x + boxB.width) - Math.max(boxA.x, boxB.x);
+        const overlapY = Math.min(boxA.y + boxA.height, boxB.y + boxB.height) - Math.max(boxA.y, boxB.y);
+        if (overlapX > 0 && overlapY > 0) {
+          const overlapArea = overlapX * overlapY;
+          const smallerArea = Math.min(
+            boxA.width * boxA.height,
+            boxB.width * boxB.height
+          );
+          if (overlapArea > smallerArea * 0.2) {
+            significantOverlapCount++;
+          }
+        }
+      }
+    }
+  }
+  if (significantOverlapCount > 0) {
+    return {
+      ruleId: zIndexDependentLayoutDef.id,
+      nodeId: node.id,
+      nodePath: context.path.join(" > "),
+      message: `"${node.name}" uses layer stacking for layout (${significantOverlapCount} overlaps)`
+    };
+  }
+  return null;
+};
+defineRule({
+  definition: zIndexDependentLayoutDef,
+  check: zIndexDependentLayoutCheck
+});
+var missingLayoutHintDef = {
+  id: "missing-layout-hint",
+  name: "Missing Layout Hint",
+  category: "ai-readability",
+  why: "Complex nesting without Auto Layout makes structure unpredictable",
+  impact: "AI may generate incorrect code due to ambiguous relationships",
+  fix: "Add Auto Layout or simplify the nesting structure"
+};
+var missingLayoutHintCheck = (node, context) => {
+  if (!isContainerNode2(node)) return null;
+  if (hasAutoLayout2(node)) return null;
+  if (!node.children || node.children.length === 0) return null;
+  const nestedContainers = node.children.filter((c) => isContainerNode2(c));
+  if (nestedContainers.length >= 2) {
+    const withoutLayout = nestedContainers.filter((c) => !hasAutoLayout2(c));
+    if (withoutLayout.length >= 2) {
+      return {
+        ruleId: missingLayoutHintDef.id,
+        nodeId: node.id,
+        nodePath: context.path.join(" > "),
+        message: `"${node.name}" has ${withoutLayout.length} nested containers without layout hints`
+      };
+    }
+  }
+  return null;
+};
+defineRule({
+  definition: missingLayoutHintDef,
+  check: missingLayoutHintCheck
+});
+var invisibleLayerDef = {
+  id: "invisible-layer",
+  name: "Invisible Layer",
+  category: "ai-readability",
+  why: "Hidden layers add noise and may confuse analysis tools",
+  impact: "Exported code may include unnecessary elements",
+  fix: "Delete hidden layers or move them to a separate 'archive' page"
+};
+var invisibleLayerCheck = (node, context) => {
+  if (node.visible !== false) return null;
+  if (context.parent?.visible === false) return null;
+  return {
+    ruleId: invisibleLayerDef.id,
+    nodeId: node.id,
+    nodePath: context.path.join(" > "),
+    message: `"${node.name}" is hidden - consider removing if not needed`
+  };
+};
+defineRule({
+  definition: invisibleLayerDef,
+  check: invisibleLayerCheck
+});
+var emptyFrameDef = {
+  id: "empty-frame",
+  name: "Empty Frame",
+  category: "ai-readability",
+  why: "Empty frames add noise and may indicate incomplete design",
+  impact: "Generates unnecessary wrapper elements in code",
+  fix: "Remove the frame or add content"
+};
+var emptyFrameCheck = (node, context) => {
+  if (node.type !== "FRAME") return null;
+  if (node.children && node.children.length > 0) return null;
+  if (node.absoluteBoundingBox) {
+    const { width, height } = node.absoluteBoundingBox;
+    if (width <= 48 && height <= 48) return null;
+  }
+  return {
+    ruleId: emptyFrameDef.id,
+    nodeId: node.id,
+    nodePath: context.path.join(" > "),
+    message: `"${node.name}" is an empty frame`
+  };
+};
+defineRule({
+  definition: emptyFrameDef,
+  check: emptyFrameCheck
+});
+
+// src/rules/handoff-risk/index.ts
+function hasAutoLayout3(node) {
+  return node.layoutMode !== void 0 && node.layoutMode !== "NONE";
+}
+function isContainerNode3(node) {
+  return node.type === "FRAME" || node.type === "GROUP" || node.type === "COMPONENT";
+}
+function isTextNode(node) {
+  return node.type === "TEXT";
+}
+function isImageNode(node) {
+  if (node.type === "RECTANGLE" && node.fills) {
+    for (const fill of node.fills) {
+      const fillObj = fill;
+      if (fillObj["type"] === "IMAGE") return true;
+    }
+  }
+  return false;
+}
+var hardcodeRiskDef = {
+  id: "hardcode-risk",
+  name: "Hardcode Risk",
+  category: "handoff-risk",
+  why: "Absolute positioning with fixed values creates inflexible layouts",
+  impact: "Layout will break when content changes or on different screens",
+  fix: "Use Auto Layout with relative positioning"
+};
+var hardcodeRiskCheck = (node, context) => {
+  if (!isContainerNode3(node)) return null;
+  if (node.layoutPositioning !== "ABSOLUTE") return null;
+  if (context.parent && hasAutoLayout3(context.parent)) {
+    return {
+      ruleId: hardcodeRiskDef.id,
+      nodeId: node.id,
+      nodePath: context.path.join(" > "),
+      message: `"${node.name}" uses absolute positioning with fixed values`
+    };
+  }
+  return null;
+};
+defineRule({
+  definition: hardcodeRiskDef,
+  check: hardcodeRiskCheck
+});
+var textTruncationUnhandledDef = {
+  id: "text-truncation-unhandled",
+  name: "Text Truncation Unhandled",
+  category: "handoff-risk",
+  why: "Text nodes without truncation handling may overflow",
+  impact: "Long text will break the layout",
+  fix: "Set text truncation (ellipsis) or ensure container can grow"
+};
+var textTruncationUnhandledCheck = (node, context) => {
+  if (!isTextNode(node)) return null;
+  if (!context.parent) return null;
+  if (!hasAutoLayout3(context.parent)) return null;
+  if (node.absoluteBoundingBox) {
+    const { width } = node.absoluteBoundingBox;
+    if (node.characters && node.characters.length > 50 && width < 300) {
+      return {
+        ruleId: textTruncationUnhandledDef.id,
+        nodeId: node.id,
+        nodePath: context.path.join(" > "),
+        message: `"${node.name}" may need text truncation handling`
+      };
+    }
+  }
+  return null;
+};
+defineRule({
+  definition: textTruncationUnhandledDef,
+  check: textTruncationUnhandledCheck
+});
+var imageNoPlaceholderDef = {
+  id: "image-no-placeholder",
+  name: "Image No Placeholder",
+  category: "handoff-risk",
+  why: "Images without placeholder state may cause layout shifts",
+  impact: "Poor user experience during image loading",
+  fix: "Define a placeholder state or background color"
+};
+var imageNoPlaceholderCheck = (node, context) => {
+  if (!isImageNode(node)) return null;
+  if (node.fills && Array.isArray(node.fills) && node.fills.length === 1) {
+    const fill = node.fills[0];
+    if (fill["type"] === "IMAGE") {
+      return {
+        ruleId: imageNoPlaceholderDef.id,
+        nodeId: node.id,
+        nodePath: context.path.join(" > "),
+        message: `"${node.name}" image has no placeholder fill`
+      };
+    }
+  }
+  return null;
+};
+defineRule({
+  definition: imageNoPlaceholderDef,
+  check: imageNoPlaceholderCheck
+});
+var prototypeLinkInDesignDef = {
+  id: "prototype-link-in-design",
+  name: "Prototype Link in Design",
+  category: "handoff-risk",
+  why: "Prototype connections may affect how the design is interpreted",
+  impact: "Developers may misunderstand which elements should be interactive",
+  fix: "Document interactions separately or use clear naming"
+};
+var prototypeLinkInDesignCheck = (_node, _context) => {
+  return null;
+};
+defineRule({
+  definition: prototypeLinkInDesignDef,
+  check: prototypeLinkInDesignCheck
+});
+var noDevStatusDef = {
+  id: "no-dev-status",
+  name: "No Dev Status",
+  category: "handoff-risk",
+  why: "Without dev status, developers cannot know if a design is ready",
+  impact: "May implement designs that are still in progress",
+  fix: "Mark frames as 'Ready for Dev' or 'Completed' when appropriate"
+};
+var noDevStatusCheck = (node, context) => {
+  if (node.type !== "FRAME") return null;
+  if (context.depth > 1) return null;
+  if (node.devStatus) return null;
+  return {
+    ruleId: noDevStatusDef.id,
+    nodeId: node.id,
+    nodePath: context.path.join(" > "),
+    message: `"${node.name}" has no dev status set`
+  };
+};
+defineRule({
+  definition: noDevStatusDef,
+  check: noDevStatusCheck
+});
+
+// src/mcp/server.ts
+config();
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../../package.json");
+var server = new McpServer({
+  name: "canicode",
+  version: pkg.version
+});
+server.tool(
+  "analyze",
+  `Analyze a Figma design for development-friendliness and AI-friendliness.
+
+Two ways to provide design data:
+1. designData \u2014 Pass Figma node data directly (from Figma MCP get_metadata). Recommended when using Figma MCP.
+2. input \u2014 Figma URL (fetches via REST API, requires FIGMA_TOKEN).
+
+Typical flow with Figma MCP:
+  Step 1: Call Figma MCP get_metadata to get the node tree
+  Step 2: Pass the result as designData to this tool`,
+  {
+    designData: z.string().optional().describe("Figma node data from Figma MCP get_metadata (XML or JSON). Pass this instead of input when using Figma MCP."),
+    input: z.string().optional().describe("Figma URL. Used when designData is not provided. Requires FIGMA_TOKEN."),
+    fileKey: z.string().optional().describe("Figma file key (used with designData to generate deep links)"),
+    fileName: z.string().optional().describe("Figma file name (used with designData for display)"),
+    token: z.string().optional().describe("Figma API token (falls back to FIGMA_TOKEN env var)"),
+    preset: z.enum(["relaxed", "dev-friendly", "ai-ready", "strict"]).optional().describe("Analysis preset"),
+    targetNodeId: z.string().optional().describe("Scope analysis to a specific node ID"),
+    configPath: z.string().optional().describe("Path to config JSON file for rule overrides"),
+    customRulesPath: z.string().optional().describe("Path to custom rules JSON file")
+  },
+  async ({ designData, input, fileKey, fileName, token, preset, targetNodeId, configPath, customRulesPath }) => {
+    try {
+      let file;
+      let nodeId;
+      if (designData) {
+        file = parseDesignData(designData, fileKey ?? "unknown", fileName);
+      } else if (input) {
+        const loaded = await loadFile(input, token, "api");
+        file = loaded.file;
+        nodeId = loaded.nodeId;
+      } else {
+        throw new Error("Provide either designData (from Figma MCP) or input (Figma URL).");
+      }
+      const effectiveNodeId = targetNodeId ?? nodeId;
+      let configs = preset ? { ...getConfigsWithPreset(preset) } : { ...RULE_CONFIGS };
+      if (configPath) {
+        const configFile = await loadConfigFile(configPath);
+        configs = mergeConfigs(configs, configFile);
+      }
+      if (customRulesPath) {
+        const { rules, configs: customConfigs } = await loadCustomRules(customRulesPath);
+        for (const rule of rules) {
+          ruleRegistry.register(rule);
+        }
+        configs = { ...configs, ...customConfigs };
+      }
+      const result = analyzeFile(file, {
+        configs,
+        ...effectiveNodeId ? { targetNodeId: effectiveNodeId } : {}
+      });
+      const scores = calculateScores(result);
+      const summary = formatScoreSummary(scores);
+      const figmaToken = token ?? process.env["FIGMA_TOKEN"];
+      const html = generateHtmlReport(file, result, scores, { figmaToken });
+      const now = /* @__PURE__ */ new Date();
+      const ts = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}-${String(now.getHours()).padStart(2, "0")}-${String(now.getMinutes()).padStart(2, "0")}`;
+      ensureReportsDir();
+      const reportPath = `${getReportsDir()}/report-${ts}-${file.fileKey}.html`;
+      await new Promise((resolve4, reject) => {
+        writeFile(reportPath, html, "utf-8", (err) => {
+          if (err) reject(err);
+          else resolve4();
+        });
+      });
+      const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+      exec(`${openCmd} "${reportPath}"`);
+      const issuesByRule = {};
+      for (const issue of result.issues) {
+        const id = issue.violation.ruleId;
+        issuesByRule[id] = (issuesByRule[id] ?? 0) + 1;
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                fileName: file.name,
+                nodeCount: result.nodeCount,
+                maxDepth: result.maxDepth,
+                issueCount: result.issues.length,
+                scores: {
+                  overall: scores.overall,
+                  categories: scores.byCategory
+                },
+                issuesByRule,
+                summary
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error instanceof Error ? error.message : String(error)}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "list-rules",
+  "List all available analysis rules with their current configuration",
+  {},
+  async () => {
+    const rules = ruleRegistry.getAll().map((rule) => {
+      const config2 = RULE_CONFIGS[rule.definition.id];
+      return {
+        id: rule.definition.id,
+        name: rule.definition.name,
+        category: rule.definition.category,
+        severity: config2?.severity,
+        score: config2?.score,
+        enabled: config2?.enabled,
+        why: rule.definition.why
+      };
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(rules, null, 2)
+        }
+      ]
+    };
+  }
+);
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch(console.error);
+//# sourceMappingURL=server.js.map
+//# sourceMappingURL=server.js.map