canicode 0.3.0

package/dist/index.js

@@ -0,0 +1,3513 @@
+import { z } from 'zod';
+import { readFile, writeFile, appendFile } from 'fs/promises';
+import { basename, resolve, dirname } from 'path';
+import { existsSync, mkdirSync } from 'fs';
+
+// src/contracts/severity.ts
+var SeveritySchema = z.enum([
+  "blocking",
+  "risk",
+  "missing-info",
+  "suggestion"
+]);
+var SEVERITY_WEIGHT = {
+  blocking: 10,
+  risk: 5,
+  "missing-info": 2,
+  suggestion: 1
+};
+var SEVERITY_LABELS = {
+  blocking: "Blocking",
+  risk: "Risk",
+  "missing-info": "Missing Info",
+  suggestion: "Suggestion"
+};
+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 AnalysisNodeTypeSchema = z.enum([
+  "DOCUMENT",
+  "CANVAS",
+  "FRAME",
+  "GROUP",
+  "SECTION",
+  "COMPONENT",
+  "COMPONENT_SET",
+  "INSTANCE",
+  "RECTANGLE",
+  "ELLIPSE",
+  "VECTOR",
+  "TEXT",
+  "LINE",
+  "BOOLEAN_OPERATION",
+  "STAR",
+  "REGULAR_POLYGON",
+  "SLICE",
+  "STICKY",
+  "SHAPE_WITH_TEXT",
+  "CONNECTOR",
+  "WIDGET",
+  "EMBED",
+  "LINK_UNFURL",
+  "TABLE",
+  "TABLE_CELL"
+]);
+var LayoutModeSchema = z.enum(["NONE", "HORIZONTAL", "VERTICAL"]);
+var LayoutAlignSchema = z.enum(["MIN", "CENTER", "MAX", "STRETCH", "INHERIT"]);
+var LayoutPositioningSchema = z.enum(["AUTO", "ABSOLUTE"]);
+var BaseAnalysisNodeSchema = z.object({
+  // Basic identification
+  id: z.string(),
+  name: z.string(),
+  type: AnalysisNodeTypeSchema,
+  visible: z.boolean().default(true),
+  // Layout analysis
+  layoutMode: LayoutModeSchema.optional(),
+  layoutAlign: LayoutAlignSchema.optional(),
+  layoutPositioning: LayoutPositioningSchema.optional(),
+  primaryAxisAlignItems: z.string().optional(),
+  counterAxisAlignItems: z.string().optional(),
+  itemSpacing: z.number().optional(),
+  paddingLeft: z.number().optional(),
+  paddingRight: z.number().optional(),
+  paddingTop: z.number().optional(),
+  paddingBottom: z.number().optional(),
+  // Size/position analysis
+  absoluteBoundingBox: z.object({
+    x: z.number(),
+    y: z.number(),
+    width: z.number(),
+    height: z.number()
+  }).nullable().optional(),
+  // Component analysis
+  componentId: z.string().optional(),
+  componentPropertyDefinitions: z.record(z.string(), z.unknown()).optional(),
+  componentProperties: z.record(z.string(), z.unknown()).optional(),
+  // Style/token analysis
+  styles: z.record(z.string(), z.string()).optional(),
+  fills: z.array(z.unknown()).optional(),
+  strokes: z.array(z.unknown()).optional(),
+  effects: z.array(z.unknown()).optional(),
+  // Variable binding analysis (design tokens)
+  boundVariables: z.record(z.string(), z.unknown()).optional(),
+  // Text analysis
+  characters: z.string().optional(),
+  style: z.record(z.string(), z.unknown()).optional(),
+  // Handoff analysis
+  devStatus: z.object({
+    type: z.enum(["NONE", "READY_FOR_DEV", "COMPLETED"]),
+    description: z.string().optional()
+  }).optional(),
+  // Naming analysis metadata
+  isAsset: z.boolean().optional()
+});
+var AnalysisNodeSchema = BaseAnalysisNodeSchema.extend({
+  children: z.lazy(() => AnalysisNodeSchema.array().optional())
+});
+var AnalysisFileSchema = z.object({
+  fileKey: z.string(),
+  name: z.string(),
+  lastModified: z.string(),
+  version: z.string(),
+  document: AnalysisNodeSchema,
+  components: z.record(
+    z.string(),
+    z.object({
+      key: z.string(),
+      name: z.string(),
+      description: z.string()
+    })
+  ),
+  styles: z.record(
+    z.string(),
+    z.object({
+      key: z.string(),
+      name: z.string(),
+      styleType: z.string()
+    })
+  )
+});
+var RuleDefinitionSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  category: CategorySchema,
+  why: z.string(),
+  impact: z.string(),
+  fix: z.string()
+});
+var RuleConfigSchema = 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);
+}
+var IssueSchema = z.object({
+  nodeId: z.string(),
+  nodePath: z.string(),
+  figmaDeepLink: z.string().url(),
+  ruleId: z.string(),
+  message: z.string(),
+  severity: SeveritySchema
+});
+var CategoryScoreSchema = z.object({
+  category: CategorySchema,
+  score: z.number().min(0).max(100),
+  maxScore: z.number().min(0).max(100),
+  issueCount: z.object({
+    error: z.number().int().min(0),
+    warning: z.number().int().min(0),
+    info: z.number().int().min(0)
+  })
+});
+var ReportMetadataSchema = z.object({
+  fileKey: z.string(),
+  fileName: z.string(),
+  analyzedAt: z.string().datetime(),
+  version: z.string()
+});
+var ReportSchema = z.object({
+  metadata: ReportMetadataSchema,
+  totalScore: z.number().min(0).max(100),
+  categoryScores: z.array(CategoryScoreSchema),
+  issues: z.array(IssueSchema),
+  summary: z.object({
+    totalNodes: z.number().int().min(0),
+    analyzedNodes: z.number().int().min(0),
+    errorCount: z.number().int().min(0),
+    warningCount: z.number().int().min(0),
+    infoCount: z.number().int().min(0)
+  })
+});
+
+// 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, config] of Object.entries(configs)) {
+        if (config.severity === "blocking") {
+          configs[id] = {
+            ...config,
+            severity: "risk",
+            score: Math.round(config.score * 0.5)
+          };
+        }
+      }
+      break;
+    case "dev-friendly":
+      for (const [id, config] of Object.entries(configs)) {
+        const ruleId = id;
+        if (!ruleId.includes("layout") && !ruleId.includes("handoff") && !ruleId.includes("responsive")) {
+          configs[ruleId] = { ...config, enabled: false };
+        }
+      }
+      break;
+    case "ai-ready":
+      for (const [id, config] of Object.entries(configs)) {
+        const ruleId = id;
+        if (ruleId.includes("ambiguous") || ruleId.includes("structure") || ruleId.includes("name")) {
+          configs[ruleId] = {
+            ...config,
+            score: Math.round(config.score * 1.5)
+          };
+        }
+      }
+      break;
+    case "strict":
+      for (const [id, config] of Object.entries(configs)) {
+        configs[id] = {
+          ...config,
+          enabled: true,
+          score: Math.round(config.score * 1.5)
+        };
+      }
+      break;
+  }
+  return configs;
+}
+function getRuleOption(ruleId, optionKey, defaultValue) {
+  const config = RULE_CONFIGS[ruleId];
+  if (!config.options) return defaultValue;
+  const value = config.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 config = configs[rule.definition.id];
+      return config?.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 config = this.configs[ruleId];
+      return config?.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 config = this.configs[ruleId];
+      const options = config?.options;
+      try {
+        const violation = rule.check(node, context, options);
+        if (violation) {
+          let calculatedScore = config.score;
+          if (supportsDepthWeight(rule.definition.category) && config.depthWeight) {
+            const weight = calcDepthWeight(depth, maxDepth, config.depthWeight);
+            calculatedScore = Math.round(config.score * weight);
+          }
+          issues.push({
+            violation,
+            rule,
+            config,
+            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/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 gradeToClassName(grade) {
+  return grade.replace("+", "plus");
+}
+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");
+}
+function getCategoryLabel(category) {
+  const labels = {
+    layout: "Layout",
+    token: "Design Token",
+    component: "Component",
+    naming: "Naming",
+    "ai-readability": "AI Readability",
+    "handoff-risk": "Handoff Risk"
+  };
+  return labels[category];
+}
+function getSeverityLabel(severity) {
+  const labels = {
+    blocking: "Blocking",
+    risk: "Risk",
+    "missing-info": "Missing Info",
+    suggestion: "Suggestion"
+  };
+  return labels[severity];
+}
+
+// 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`
+  };
+};
+var noAutoLayout = 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.`
+  };
+};
+var absolutePositionInAutoLayout = 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`
+  };
+};
+var fixedWidthInResponsiveContext = 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;
+};
+var missingResponsiveBehavior = 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`
+  };
+};
+var groupUsage = 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;
+};
+var fixedSizeInAutoLayout = 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;
+};
+var missingMinWidth = 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;
+};
+var missingMaxWidth = 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})`
+  };
+};
+var deepNesting = 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;
+};
+var overflowHiddenAbuse = 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;
+};
+var inconsistentSiblingLayoutDirection = 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;
+};
+var rawColor = 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`
+  };
+};
+var rawFont = 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;
+};
+var inconsistentSpacing = 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;
+};
+var magicNumberSpacing = 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;
+};
+var rawShadow = 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;
+};
+var rawOpacity = 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;
+};
+var multipleFillColors = 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;
+};
+var missingComponent = 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;
+};
+var detachedInstance = 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;
+};
+var nestedInstanceOverride = 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;
+};
+var variantNotUsed = 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;
+};
+var componentPropertyUnused = 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;
+};
+var singleUseComponent = 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`
+  };
+};
+var defaultName = 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`
+  };
+};
+var nonSemanticName = 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;
+};
+var inconsistentNamingConvention = 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`
+  };
+};
+var numericSuffixName = 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})`
+  };
+};
+var tooLongName = 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;
+};
+var ambiguousStructure = 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;
+};
+var zIndexDependentLayout = 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;
+};
+var missingLayoutHint = 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`
+  };
+};
+var invisibleLayer = 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`
+  };
+};
+var emptyFrame = 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;
+};
+var hardcodeRisk = 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;
+};
+var textTruncationUnhandled = 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;
+};
+var imageNoPlaceholder = 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;
+};
+var prototypeLinkInDesign = 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`
+  };
+};
+var noDevStatus = defineRule({
+  definition: noDevStatusDef,
+  check: noDevStatusCheck
+});
+var FigmaUrlInfoSchema = 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-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;
+}
+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);
+}
+function parseFigmaJson(json, fileKey) {
+  const data = JSON.parse(json);
+  return transformFigmaResponse(fileKey, data);
+}
+var FigmaFileLoadError = class extends Error {
+  constructor(message, filePath) {
+    super(message);
+    this.filePath = filePath;
+    this.name = "FigmaFileLoadError";
+  }
+};
+
+// 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 SamplingStrategySchema = z.enum(["all", "top-issues", "random"]);
+var CalibrationStatusSchema = z.enum([
+  "pending",
+  "analyzing",
+  "converting",
+  "evaluating",
+  "tuning",
+  "completed",
+  "failed"
+]);
+var CalibrationConfigSchema = z.object({
+  input: z.string(),
+  token: z.string().optional(),
+  targetNodeId: z.string().optional(),
+  maxConversionNodes: z.number().int().positive().default(20),
+  samplingStrategy: SamplingStrategySchema.default("top-issues"),
+  outputPath: z.string().default("logs/calibration/calibration-report.md")
+});
+var NodeIssueSummarySchema = z.object({
+  nodeId: z.string(),
+  nodePath: z.string(),
+  totalScore: z.number(),
+  issueCount: z.number(),
+  flaggedRuleIds: z.array(z.string()),
+  severities: z.array(z.string())
+});
+var DifficultySchema = z.enum(["easy", "moderate", "hard", "failed"]);
+var RuleRelatedStruggleSchema = z.object({
+  ruleId: z.string(),
+  description: z.string(),
+  actualImpact: DifficultySchema
+});
+var UncoveredStruggleSchema = z.object({
+  description: z.string(),
+  suggestedCategory: z.string(),
+  estimatedImpact: DifficultySchema
+});
+var ConversionRecordSchema = z.object({
+  nodeId: z.string(),
+  nodePath: z.string(),
+  generatedCode: z.string(),
+  difficulty: DifficultySchema,
+  notes: z.string(),
+  ruleRelatedStruggles: z.array(RuleRelatedStruggleSchema),
+  uncoveredStruggles: z.array(UncoveredStruggleSchema),
+  durationMs: z.number()
+});
+var MismatchTypeSchema = z.enum([
+  "overscored",
+  "underscored",
+  "missing-rule",
+  "validated"
+]);
+var MismatchCaseSchema = z.object({
+  type: MismatchTypeSchema,
+  nodeId: z.string(),
+  nodePath: z.string(),
+  ruleId: z.string().optional(),
+  currentScore: z.number().optional(),
+  currentSeverity: SeveritySchema.optional(),
+  actualDifficulty: DifficultySchema,
+  reasoning: z.string()
+});
+var ConfidenceSchema = z.enum(["high", "medium", "low"]);
+var ScoreAdjustmentSchema = z.object({
+  ruleId: z.string(),
+  currentScore: z.number(),
+  proposedScore: z.number(),
+  currentSeverity: SeveritySchema,
+  proposedSeverity: SeveritySchema.optional(),
+  reasoning: z.string(),
+  confidence: ConfidenceSchema,
+  supportingCases: z.number()
+});
+var NewRuleProposalSchema = z.object({
+  suggestedId: z.string(),
+  category: z.string(),
+  description: z.string(),
+  suggestedSeverity: SeveritySchema,
+  suggestedScore: z.number(),
+  reasoning: z.string(),
+  supportingCases: z.number()
+});
+
+// src/agents/analysis-agent.ts
+function buildNodeIssueSummaries(result) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const issue of result.issues) {
+    const nodeId = issue.violation.nodeId;
+    const existing = nodeMap.get(nodeId);
+    if (existing) {
+      existing.totalScore += issue.calculatedScore;
+      existing.issueCount++;
+      existing.ruleIds.add(issue.rule.definition.id);
+      existing.severities.add(issue.config.severity);
+    } else {
+      nodeMap.set(nodeId, {
+        nodePath: issue.violation.nodePath,
+        totalScore: issue.calculatedScore,
+        issueCount: 1,
+        ruleIds: /* @__PURE__ */ new Set([issue.rule.definition.id]),
+        severities: /* @__PURE__ */ new Set([issue.config.severity])
+      });
+    }
+  }
+  const summaries = [];
+  for (const [nodeId, data] of nodeMap) {
+    summaries.push({
+      nodeId,
+      nodePath: data.nodePath,
+      totalScore: data.totalScore,
+      issueCount: data.issueCount,
+      flaggedRuleIds: [...data.ruleIds],
+      severities: [...data.severities]
+    });
+  }
+  summaries.sort((a, b) => a.totalScore - b.totalScore);
+  return summaries;
+}
+function extractRuleScores(result) {
+  const scores = {};
+  for (const issue of result.issues) {
+    const ruleId = issue.rule.definition.id;
+    if (!scores[ruleId]) {
+      scores[ruleId] = {
+        score: issue.config.score,
+        severity: issue.config.severity
+      };
+    }
+  }
+  return scores;
+}
+function runAnalysisAgent(input) {
+  const { analysisResult } = input;
+  const scoreReport = calculateScores(analysisResult);
+  const nodeIssueSummaries = buildNodeIssueSummaries(analysisResult);
+  return {
+    analysisResult,
+    scoreReport,
+    nodeIssueSummaries
+  };
+}
+
+// src/agents/conversion-agent.ts
+async function runConversionAgent(input, executor) {
+  const records = [];
+  const skippedNodeIds = [];
+  for (const node of input.nodes) {
+    const startTime = Date.now();
+    try {
+      const result = await executor(
+        node.nodeId,
+        input.fileKey,
+        node.flaggedRuleIds
+      );
+      const durationMs = Date.now() - startTime;
+      records.push({
+        nodeId: node.nodeId,
+        nodePath: node.nodePath,
+        generatedCode: result.generatedCode,
+        difficulty: result.difficulty,
+        notes: result.notes,
+        ruleRelatedStruggles: result.ruleRelatedStruggles,
+        uncoveredStruggles: result.uncoveredStruggles,
+        durationMs
+      });
+    } catch {
+      skippedNodeIds.push(node.nodeId);
+    }
+  }
+  return { records, skippedNodeIds };
+}
+
+// src/agents/conversion-agent.prompt.ts
+function buildConversionPrompt(nodeId, fileKey, flaggedRuleIds) {
+  const ruleList = flaggedRuleIds.length > 0 ? flaggedRuleIds.map((id) => `- ${id}`).join("\n") : "- (none)";
+  return `You are a frontend developer converting a Figma design node to production-ready CSS/HTML/React code.
+
+## Task
+
+Convert the Figma node to code, then assess the conversion difficulty.
+
+## Node Information
+- **File Key**: ${fileKey}
+- **Node ID**: ${nodeId}
+
+Use \`get_design_context\` to fetch the node's design details before attempting conversion.
+
+## Flagged Design Issues
+
+The following rules were flagged by the design readiness checker for this node:
+${ruleList}
+
+## Instructions
+
+1. Fetch the node's design context using MCP
+2. Attempt to convert it to production-ready CSS + HTML (or React component)
+3. For each flagged rule, note whether it actually made conversion harder
+4. Note any conversion difficulties NOT covered by the flagged rules
+
+## Output Format
+
+Respond with a JSON object matching this structure:
+
+\`\`\`json
+{
+  "generatedCode": "// The generated CSS/HTML/React code",
+  "difficulty": "easy | moderate | hard | failed",
+  "notes": "Brief summary of the conversion experience",
+  "ruleRelatedStruggles": [
+    {
+      "ruleId": "rule-id",
+      "description": "How this rule's issue affected conversion",
+      "actualImpact": "easy | moderate | hard | failed"
+    }
+  ],
+  "uncoveredStruggles": [
+    {
+      "description": "A difficulty not covered by any flagged rule",
+      "suggestedCategory": "layout | token | component | naming | ai-readability | handoff-risk",
+      "estimatedImpact": "easy | moderate | hard | failed"
+    }
+  ]
+}
+\`\`\`
+
+## Difficulty Guidelines
+
+- **easy**: Straightforward conversion, no guessing needed
+- **moderate**: Some ambiguity or manual adjustment required
+- **hard**: Significant guessing, multiple approaches needed, fragile output
+- **failed**: Could not produce usable code from the design
+`;
+}
+
+// src/agents/evaluation-agent.ts
+var DIFFICULTY_SCORE_RANGES = {
+  easy: { min: -3, max: 0 },
+  moderate: { min: -7, max: -4 },
+  hard: { min: -12, max: -8 },
+  failed: { min: -12, max: -8 }
+};
+function scoreMatchesDifficulty(score, difficulty) {
+  const range = DIFFICULTY_SCORE_RANGES[difficulty];
+  return score >= range.min && score <= range.max;
+}
+function classifyFlaggedRule(currentScore, actualDifficulty) {
+  if (scoreMatchesDifficulty(currentScore, actualDifficulty)) {
+    return "validated";
+  }
+  if (actualDifficulty === "easy" && currentScore < -3 || actualDifficulty === "moderate" && currentScore < -7) {
+    return "overscored";
+  }
+  return "underscored";
+}
+function buildReasoning(type, ruleId, currentScore, actualDifficulty) {
+  const range = DIFFICULTY_SCORE_RANGES[actualDifficulty];
+  switch (type) {
+    case "validated":
+      return `Rule "${ruleId}" score (${currentScore}) aligns with actual difficulty "${actualDifficulty}" (expected range: ${range.min} to ${range.max}).`;
+    case "overscored":
+      return `Rule "${ruleId}" score (${currentScore}) is too harsh for actual difficulty "${actualDifficulty}" (expected range: ${range.min} to ${range.max}).`;
+    case "underscored":
+      return `Rule "${ruleId}" score (${currentScore}) is too lenient for actual difficulty "${actualDifficulty}" (expected range: ${range.min} to ${range.max}).`;
+    case "missing-rule":
+      return `No rule covers this difficulty "${actualDifficulty}" (expected score range: ${range.min} to ${range.max}).`;
+  }
+}
+function runEvaluationAgent(input) {
+  const mismatches = [];
+  const validatedRuleSet = /* @__PURE__ */ new Set();
+  const nodeSummaryMap = new Map(
+    input.nodeIssueSummaries.map((s) => [s.nodeId, s])
+  );
+  for (const record of input.conversionRecords) {
+    const summary = nodeSummaryMap.get(record.nodeId);
+    const difficulty = record.difficulty;
+    for (const struggle of record.ruleRelatedStruggles) {
+      const ruleInfo = input.ruleScores[struggle.ruleId];
+      if (!ruleInfo) continue;
+      const actualDifficulty = struggle.actualImpact;
+      const type = classifyFlaggedRule(ruleInfo.score, actualDifficulty);
+      if (type === "validated") {
+        validatedRuleSet.add(struggle.ruleId);
+      }
+      mismatches.push({
+        type,
+        nodeId: record.nodeId,
+        nodePath: record.nodePath,
+        ruleId: struggle.ruleId,
+        currentScore: ruleInfo.score,
+        currentSeverity: ruleInfo.severity,
+        actualDifficulty,
+        reasoning: buildReasoning(type, struggle.ruleId, ruleInfo.score, actualDifficulty)
+      });
+    }
+    if (summary) {
+      const struggledRuleIds = new Set(
+        record.ruleRelatedStruggles.map((s) => s.ruleId)
+      );
+      for (const ruleId of summary.flaggedRuleIds) {
+        if (struggledRuleIds.has(ruleId)) continue;
+        const ruleInfo = input.ruleScores[ruleId];
+        if (!ruleInfo) continue;
+        if (difficulty === "easy" || difficulty === "moderate") {
+          mismatches.push({
+            type: "overscored",
+            nodeId: record.nodeId,
+            nodePath: record.nodePath,
+            ruleId,
+            currentScore: ruleInfo.score,
+            currentSeverity: ruleInfo.severity,
+            actualDifficulty: "easy",
+            reasoning: `Rule "${ruleId}" was flagged but caused no struggle during conversion (overall node difficulty: "${difficulty}").`
+          });
+        } else {
+          validatedRuleSet.add(ruleId);
+          mismatches.push({
+            type: "validated",
+            nodeId: record.nodeId,
+            nodePath: record.nodePath,
+            ruleId,
+            currentScore: ruleInfo.score,
+            currentSeverity: ruleInfo.severity,
+            actualDifficulty: difficulty,
+            reasoning: `Rule "${ruleId}" was flagged and overall conversion was "${difficulty}" \u2014 conservatively validated.`
+          });
+        }
+      }
+    }
+    for (const uncovered of record.uncoveredStruggles) {
+      const estimatedDifficulty = uncovered.estimatedImpact;
+      mismatches.push({
+        type: "missing-rule",
+        nodeId: record.nodeId,
+        nodePath: record.nodePath,
+        actualDifficulty: estimatedDifficulty,
+        reasoning: `Uncovered struggle: "${uncovered.description}" (category: ${uncovered.suggestedCategory}, impact: ${estimatedDifficulty}).`
+      });
+    }
+  }
+  return {
+    mismatches,
+    validatedRules: [...validatedRuleSet]
+  };
+}
+
+// src/agents/tuning-agent.ts
+var DIFFICULTY_MIDPOINT = {
+  easy: -2,
+  moderate: -5,
+  hard: -10,
+  failed: -12
+};
+var DIFFICULTY_SEVERITY = {
+  easy: "suggestion",
+  moderate: "risk",
+  hard: "blocking",
+  failed: "blocking"
+};
+function getConfidence(caseCount) {
+  if (caseCount >= 3) return "high";
+  if (caseCount >= 2) return "medium";
+  return "low";
+}
+function proposedScoreFromDifficulties(difficulties) {
+  const counts = {};
+  for (const d of difficulties) {
+    counts[d] = (counts[d] ?? 0) + 1;
+  }
+  let dominant = difficulties[0] ?? "moderate";
+  let maxCount = 0;
+  for (const [difficulty, count] of Object.entries(counts)) {
+    if (count > maxCount) {
+      maxCount = count;
+      dominant = difficulty;
+    }
+  }
+  return DIFFICULTY_MIDPOINT[dominant] ?? -5;
+}
+function proposeSeverity(currentSeverity, proposedScore) {
+  let expectedSeverity;
+  if (proposedScore <= -8) {
+    expectedSeverity = "blocking";
+  } else if (proposedScore <= -4) {
+    expectedSeverity = "risk";
+  } else if (proposedScore <= -2) {
+    expectedSeverity = "missing-info";
+  } else {
+    expectedSeverity = "suggestion";
+  }
+  if (expectedSeverity !== currentSeverity) {
+    return expectedSeverity;
+  }
+  return void 0;
+}
+function runTuningAgent(input) {
+  const adjustments = [];
+  const newRuleProposals = [];
+  const overscoredByRule = /* @__PURE__ */ new Map();
+  const underscoredByRule = /* @__PURE__ */ new Map();
+  const missingRuleCases = [];
+  for (const mismatch of input.mismatches) {
+    switch (mismatch.type) {
+      case "overscored": {
+        if (!mismatch.ruleId) break;
+        const existing = overscoredByRule.get(mismatch.ruleId);
+        if (existing) {
+          existing.push(mismatch);
+        } else {
+          overscoredByRule.set(mismatch.ruleId, [mismatch]);
+        }
+        break;
+      }
+      case "underscored": {
+        if (!mismatch.ruleId) break;
+        const existing = underscoredByRule.get(mismatch.ruleId);
+        if (existing) {
+          existing.push(mismatch);
+        } else {
+          underscoredByRule.set(mismatch.ruleId, [mismatch]);
+        }
+        break;
+      }
+      case "missing-rule":
+        missingRuleCases.push(mismatch);
+        break;
+    }
+  }
+  for (const [ruleId, cases] of overscoredByRule) {
+    const ruleInfo = input.ruleScores[ruleId];
+    if (!ruleInfo) continue;
+    const difficulties = cases.map((c) => c.actualDifficulty);
+    const proposedScore = proposedScoreFromDifficulties(difficulties);
+    const currentSeverity = ruleInfo.severity;
+    const newSeverity = proposeSeverity(currentSeverity, proposedScore);
+    adjustments.push({
+      ruleId,
+      currentScore: ruleInfo.score,
+      proposedScore,
+      currentSeverity,
+      proposedSeverity: newSeverity,
+      reasoning: `Overscored in ${cases.length} case(s). Actual difficulties: [${difficulties.join(", ")}]. Current score ${ruleInfo.score} is too harsh.`,
+      confidence: getConfidence(cases.length),
+      supportingCases: cases.length
+    });
+  }
+  for (const [ruleId, cases] of underscoredByRule) {
+    const ruleInfo = input.ruleScores[ruleId];
+    if (!ruleInfo) continue;
+    const difficulties = cases.map((c) => c.actualDifficulty);
+    const proposedScore = proposedScoreFromDifficulties(difficulties);
+    const currentSeverity = ruleInfo.severity;
+    const newSeverity = proposeSeverity(currentSeverity, proposedScore);
+    adjustments.push({
+      ruleId,
+      currentScore: ruleInfo.score,
+      proposedScore,
+      currentSeverity,
+      proposedSeverity: newSeverity,
+      reasoning: `Underscored in ${cases.length} case(s). Actual difficulties: [${difficulties.join(", ")}]. Current score ${ruleInfo.score} is too lenient.`,
+      confidence: getConfidence(cases.length),
+      supportingCases: cases.length
+    });
+  }
+  const missingGrouped = /* @__PURE__ */ new Map();
+  for (const c of missingRuleCases) {
+    const categoryMatch = c.reasoning.match(/category:\s*([^,)]+)/);
+    const category = categoryMatch?.[1]?.trim() ?? "unknown";
+    const existing = missingGrouped.get(category);
+    if (existing) {
+      existing.push(c);
+    } else {
+      missingGrouped.set(category, [c]);
+    }
+  }
+  for (const [category, cases] of missingGrouped) {
+    const difficulties = cases.map((c) => c.actualDifficulty);
+    const dominantDifficulty = getDominantDifficulty(difficulties);
+    const descriptions = cases.map((c) => {
+      const descMatch = c.reasoning.match(/Uncovered struggle: "([^"]+)"/);
+      return descMatch?.[1] ?? c.reasoning;
+    });
+    newRuleProposals.push({
+      suggestedId: `new-${category}-rule`,
+      category,
+      description: descriptions.join("; "),
+      suggestedSeverity: DIFFICULTY_SEVERITY[dominantDifficulty] ?? "risk",
+      suggestedScore: DIFFICULTY_MIDPOINT[dominantDifficulty] ?? -5,
+      reasoning: `${cases.length} uncovered struggle(s) in category "${category}". Difficulties: [${difficulties.join(", ")}].`,
+      supportingCases: cases.length
+    });
+  }
+  return { adjustments, newRuleProposals };
+}
+function getDominantDifficulty(difficulties) {
+  const counts = {};
+  for (const d of difficulties) {
+    counts[d] = (counts[d] ?? 0) + 1;
+  }
+  let dominant = difficulties[0] ?? "moderate";
+  let maxCount = 0;
+  for (const [difficulty, count] of Object.entries(counts)) {
+    if (count > maxCount) {
+      maxCount = count;
+      dominant = difficulty;
+    }
+  }
+  return dominant;
+}
+
+// src/agents/report-generator.ts
+function generateCalibrationReport(data) {
+  const lines = [];
+  lines.push("# Calibration Report");
+  lines.push("");
+  lines.push(renderOverview(data));
+  lines.push(renderCurrentScores(data));
+  lines.push(renderAdjustmentProposals(data.adjustments));
+  lines.push(renderNewRuleProposals(data.newRuleProposals));
+  lines.push(renderValidatedRules(data.validatedRules));
+  lines.push(renderMismatchDetails(data.mismatches));
+  lines.push(renderApplicationGuide(data.adjustments));
+  return lines.join("\n");
+}
+function renderOverview(data) {
+  return `## Overview
+
+| Metric | Value |
+|--------|-------|
+| File | ${data.fileName} (${data.fileKey}) |
+| Analyzed At | ${data.analyzedAt} |
+| Total Nodes | ${data.nodeCount} |
+| Total Issues | ${data.issueCount} |
+| Converted Nodes | ${data.convertedNodeCount} |
+| Skipped Nodes | ${data.skippedNodeCount} |
+| Overall Grade | ${data.scoreReport.overall.grade} (${data.scoreReport.overall.percentage}%) |
+`;
+}
+function renderCurrentScores(data) {
+  const lines = [];
+  lines.push("## Current Score Summary");
+  lines.push("");
+  lines.push("| Category | Score | Issues | Density | Diversity |");
+  lines.push("|----------|-------|--------|---------|-----------|");
+  for (const [category, catScore] of Object.entries(data.scoreReport.byCategory)) {
+    lines.push(
+      `| ${category} | ${catScore.percentage}% | ${catScore.issueCount} | ${catScore.densityScore} | ${catScore.diversityScore} |`
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderAdjustmentProposals(adjustments) {
+  if (adjustments.length === 0) {
+    return "## Score Adjustment Proposals\n\nNo adjustments proposed.\n";
+  }
+  const lines = [];
+  lines.push("## Score Adjustment Proposals");
+  lines.push("");
+  lines.push("| Rule | Current Score | Proposed Score | Severity Change | Confidence | Cases | Reasoning |");
+  lines.push("|------|--------------|----------------|-----------------|------------|-------|-----------|");
+  for (const adj of adjustments) {
+    const severityChange = adj.proposedSeverity ? `${adj.currentSeverity} -> ${adj.proposedSeverity}` : adj.currentSeverity;
+    lines.push(
+      `| ${adj.ruleId} | ${adj.currentScore} | ${adj.proposedScore} | ${severityChange} | ${adj.confidence} | ${adj.supportingCases} | ${adj.reasoning} |`
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderNewRuleProposals(proposals) {
+  if (proposals.length === 0) {
+    return "## New Rule Proposals\n\nNo new rules proposed.\n";
+  }
+  const lines = [];
+  lines.push("## New Rule Proposals");
+  lines.push("");
+  for (const proposal of proposals) {
+    lines.push(`### ${proposal.suggestedId}`);
+    lines.push("");
+    lines.push(`- **Category**: ${proposal.category}`);
+    lines.push(`- **Suggested Severity**: ${proposal.suggestedSeverity}`);
+    lines.push(`- **Suggested Score**: ${proposal.suggestedScore}`);
+    lines.push(`- **Supporting Cases**: ${proposal.supportingCases}`);
+    lines.push(`- **Description**: ${proposal.description}`);
+    lines.push(`- **Reasoning**: ${proposal.reasoning}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function renderValidatedRules(validatedRules) {
+  if (validatedRules.length === 0) {
+    return "## Validated Rules\n\nNo rules were validated in this run.\n";
+  }
+  const lines = [];
+  lines.push("## Validated Rules");
+  lines.push("");
+  lines.push("The following rules had scores that aligned with actual conversion difficulty:");
+  lines.push("");
+  for (const ruleId of validatedRules) {
+    lines.push(`- \`${ruleId}\``);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderMismatchDetails(mismatches) {
+  if (mismatches.length === 0) {
+    return "## Detailed Mismatch List\n\nNo mismatches found.\n";
+  }
+  const lines = [];
+  lines.push("## Detailed Mismatch List");
+  lines.push("");
+  const grouped = {};
+  for (const m of mismatches) {
+    const list = grouped[m.type];
+    if (list) {
+      list.push(m);
+    } else {
+      grouped[m.type] = [m];
+    }
+  }
+  for (const [type, cases] of Object.entries(grouped)) {
+    lines.push(`### ${type} (${cases.length})`);
+    lines.push("");
+    for (const c of cases) {
+      const ruleInfo = c.ruleId ? ` | Rule: \`${c.ruleId}\`` : "";
+      const scoreInfo = c.currentScore !== void 0 ? ` | Score: ${c.currentScore}` : "";
+      lines.push(`- **${c.nodePath}** (${c.nodeId})${ruleInfo}${scoreInfo} | Difficulty: ${c.actualDifficulty}`);
+      lines.push(`  > ${c.reasoning}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function renderApplicationGuide(adjustments) {
+  const lines = [];
+  lines.push("## Application Guide");
+  lines.push("");
+  lines.push("To apply these calibration results:");
+  lines.push("");
+  lines.push("1. Review each adjustment proposal above");
+  lines.push("2. Edit `src/rules/rule-config.ts` to update scores and severities");
+  lines.push("3. Run `pnpm test:run` to verify no tests break");
+  lines.push("4. Re-run calibration to confirm improvements");
+  lines.push("");
+  if (adjustments.length > 0) {
+    lines.push("### Suggested Changes to `rule-config.ts`");
+    lines.push("");
+    lines.push("```typescript");
+    for (const adj of adjustments) {
+      lines.push(`// ${adj.ruleId}: ${adj.currentScore} -> ${adj.proposedScore} (${adj.confidence} confidence)`);
+      if (adj.proposedSeverity) {
+        lines.push(`//   severity: "${adj.currentSeverity}" -> "${adj.proposedSeverity}"`);
+      }
+    }
+    lines.push("```");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function getTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  return now.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: false });
+}
+function getDateTimeString() {
+  const now = /* @__PURE__ */ new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  const hours = String(now.getHours()).padStart(2, "0");
+  const minutes = String(now.getMinutes()).padStart(2, "0");
+  return `${year}-${month}-${day}-${hours}-${minutes}`;
+}
+function extractFixtureName(fixturePath) {
+  const fileName = fixturePath.split("/").pop() ?? fixturePath;
+  return fileName.replace(/\.json$/, "");
+}
+var ActivityLogger = class {
+  logPath;
+  initialized = false;
+  constructor(fixturePath, logDir = "logs/activity") {
+    const dateTimeStr = getDateTimeString();
+    const fixtureName = fixturePath ? extractFixtureName(fixturePath) : "unknown";
+    this.logPath = resolve(logDir, `${dateTimeStr}-${fixtureName}.md`);
+  }
+  /**
+   * Ensure the log directory and file header exist
+   */
+  async ensureInitialized() {
+    if (this.initialized) return;
+    const dir = dirname(this.logPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    if (!existsSync(this.logPath)) {
+      const ts = getDateTimeString();
+      await writeFile(this.logPath, `# Calibration Activity Log \u2014 ${ts}
+
+`, "utf-8");
+    }
+    this.initialized = true;
+  }
+  /**
+   * Log a pipeline step
+   */
+  async logStep(activity) {
+    await this.ensureInitialized();
+    const lines = [];
+    lines.push(`## ${getTimestamp()} \u2014 ${activity.step}`);
+    if (activity.nodePath) {
+      lines.push(`- Node: ${activity.nodePath}`);
+    }
+    lines.push(`- Result: ${activity.result}`);
+    lines.push(`- Duration: ${activity.durationMs}ms`);
+    lines.push("");
+    await appendFile(this.logPath, lines.join("\n") + "\n", "utf-8");
+  }
+  /**
+   * Log a summary at pipeline completion
+   */
+  async logSummary(summary) {
+    await this.ensureInitialized();
+    const lines = [];
+    lines.push(`## ${getTimestamp()} \u2014 Pipeline Summary`);
+    lines.push(`- Status: ${summary.status}`);
+    lines.push(`- Total Duration: ${summary.totalDurationMs}ms`);
+    lines.push(`- Nodes Analyzed: ${summary.nodesAnalyzed}`);
+    lines.push(`- Nodes Converted: ${summary.nodesConverted}`);
+    lines.push(`- Mismatches Found: ${summary.mismatches}`);
+    lines.push(`- Adjustments Proposed: ${summary.adjustments}`);
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+    await appendFile(this.logPath, lines.join("\n") + "\n", "utf-8");
+  }
+  getLogPath() {
+    return this.logPath;
+  }
+};
+
+// src/agents/orchestrator.ts
+function selectNodes(summaries, strategy, maxNodes) {
+  if (summaries.length === 0) return [];
+  switch (strategy) {
+    case "all":
+      return summaries.slice(0, maxNodes);
+    case "random": {
+      const shuffled = [...summaries];
+      for (let i = shuffled.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        const temp = shuffled[i];
+        shuffled[i] = shuffled[j];
+        shuffled[j] = temp;
+      }
+      return shuffled.slice(0, maxNodes);
+    }
+    case "top-issues":
+    default:
+      return summaries.slice(0, maxNodes);
+  }
+}
+var EXCLUDED_NODE_TYPES = /* @__PURE__ */ new Set([
+  "VECTOR",
+  "BOOLEAN_OPERATION",
+  "STAR",
+  "REGULAR_POLYGON",
+  "ELLIPSE",
+  "LINE"
+]);
+function findNode(root, nodeId) {
+  if (root.id === nodeId) return root;
+  if (root.children) {
+    for (const child of root.children) {
+      const found = findNode(child, nodeId);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+function hasTextDescendant(node) {
+  if (node.type === "TEXT") return true;
+  if (node.children) {
+    for (const child of node.children) {
+      if (hasTextDescendant(child)) return true;
+    }
+  }
+  return false;
+}
+var MIN_WIDTH = 200;
+var MIN_HEIGHT = 200;
+var ELIGIBLE_NODE_TYPES = /* @__PURE__ */ new Set([
+  "FRAME",
+  "COMPONENT",
+  "INSTANCE"
+]);
+var ICON_NAME_PATTERN = /\b(icon|ico|badge|indicator)\b/i;
+function filterConversionCandidates(summaries, documentRoot) {
+  return summaries.filter((summary) => {
+    const node = findNode(documentRoot, summary.nodeId);
+    if (!node) return false;
+    if (EXCLUDED_NODE_TYPES.has(node.type)) return false;
+    if (!ELIGIBLE_NODE_TYPES.has(node.type)) return false;
+    if (ICON_NAME_PATTERN.test(node.name)) return false;
+    const bbox = node.absoluteBoundingBox;
+    if (bbox && (bbox.width < MIN_WIDTH || bbox.height < MIN_HEIGHT)) return false;
+    if (!node.children || node.children.length < 3) return false;
+    if (!hasTextDescendant(node)) return false;
+    return true;
+  });
+}
+function isFigmaUrl(input) {
+  return input.includes("figma.com/");
+}
+function isJsonFile(input) {
+  return input.endsWith(".json");
+}
+async function loadFile(input, token) {
+  if (isJsonFile(input)) {
+    const filePath = resolve(input);
+    if (!existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    const file = await loadFigmaFileFromJson(filePath);
+    return { file, fileKey: file.fileKey, nodeId: void 0 };
+  }
+  if (isFigmaUrl(input)) {
+    const { fileKey, nodeId } = parseFigmaUrl(input);
+    const figmaToken = token ?? process.env["FIGMA_TOKEN"];
+    if (!figmaToken) {
+      throw new Error(
+        "Figma token required. Provide token or set FIGMA_TOKEN environment variable."
+      );
+    }
+    const client = new FigmaClient({ token: figmaToken });
+    const response = await client.getFile(fileKey);
+    const file = transformFigmaResponse(fileKey, response);
+    return { file, fileKey, nodeId };
+  }
+  throw new Error(
+    `Invalid input: ${input}. Provide a Figma URL or JSON file path.`
+  );
+}
+function buildRuleScoresMap() {
+  const scores = {};
+  for (const [id, config] of Object.entries(RULE_CONFIGS)) {
+    scores[id] = { score: config.score, severity: config.severity };
+  }
+  return scores;
+}
+async function runCalibrationAnalyze(config) {
+  const parsed = CalibrationConfigSchema.parse(config);
+  const { file, fileKey, nodeId } = await loadFile(parsed.input, parsed.token);
+  const analyzeOptions = nodeId ? { targetNodeId: nodeId } : {};
+  const analysisResult = analyzeFile(file, analyzeOptions);
+  const analysisOutput = runAnalysisAgent({ analysisResult });
+  const ruleScores = {
+    ...buildRuleScoresMap(),
+    ...extractRuleScores(analysisResult)
+  };
+  return { analysisOutput, ruleScores, fileKey };
+}
+function runCalibrationEvaluate(analysisJson, conversionJson, ruleScores) {
+  const evaluationOutput = runEvaluationAgent({
+    nodeIssueSummaries: analysisJson.nodeIssueSummaries.map((s) => ({
+      nodeId: s.nodeId,
+      nodePath: s.nodePath,
+      flaggedRuleIds: s.flaggedRuleIds
+    })),
+    conversionRecords: conversionJson.records,
+    ruleScores
+  });
+  const tuningOutput = runTuningAgent({
+    mismatches: evaluationOutput.mismatches,
+    ruleScores
+  });
+  const report = generateCalibrationReport({
+    fileKey: analysisJson.fileKey,
+    fileName: analysisJson.fileName,
+    analyzedAt: analysisJson.analyzedAt,
+    nodeCount: analysisJson.nodeCount,
+    issueCount: analysisJson.issueCount,
+    convertedNodeCount: conversionJson.records.length,
+    skippedNodeCount: conversionJson.skippedNodeIds.length,
+    scoreReport: analysisJson.scoreReport,
+    mismatches: evaluationOutput.mismatches,
+    validatedRules: evaluationOutput.validatedRules,
+    adjustments: tuningOutput.adjustments,
+    newRuleProposals: tuningOutput.newRuleProposals
+  });
+  return {
+    evaluationOutput,
+    tuningOutput,
+    report
+  };
+}
+async function runCalibration(config, executor, options) {
+  const parsed = CalibrationConfigSchema.parse(config);
+  const pipelineStart = Date.now();
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const logger = options?.enableActivityLog ? new ActivityLogger(parsed.input) : null;
+  try {
+    let stepStart = Date.now();
+    const { file, fileKey, nodeId } = await loadFile(parsed.input, parsed.token);
+    const analyzeOptions = nodeId ? { targetNodeId: nodeId } : {};
+    const analysisResult = analyzeFile(file, analyzeOptions);
+    const analysisOutput = runAnalysisAgent({ analysisResult });
+    const ruleScores = {
+      ...buildRuleScoresMap(),
+      ...extractRuleScores(analysisResult)
+    };
+    await logger?.logStep({
+      step: "Analysis",
+      result: `${analysisResult.nodeCount} nodes, ${analysisResult.issues.length} issues, grade ${analysisOutput.scoreReport.overall.grade}`,
+      durationMs: Date.now() - stepStart
+    });
+    stepStart = Date.now();
+    const candidates = filterConversionCandidates(
+      analysisOutput.nodeIssueSummaries,
+      analysisResult.file.document
+    );
+    const selectedNodes = selectNodes(
+      candidates,
+      parsed.samplingStrategy,
+      parsed.maxConversionNodes
+    );
+    const conversionOutput = await runConversionAgent(
+      {
+        fileKey,
+        nodes: selectedNodes.map((n) => ({
+          nodeId: n.nodeId,
+          nodePath: n.nodePath,
+          flaggedRuleIds: n.flaggedRuleIds
+        }))
+      },
+      executor
+    );
+    await logger?.logStep({
+      step: "Conversion",
+      result: `${conversionOutput.records.length} converted, ${conversionOutput.skippedNodeIds.length} skipped`,
+      durationMs: Date.now() - stepStart
+    });
+    stepStart = Date.now();
+    const evaluationOutput = runEvaluationAgent({
+      nodeIssueSummaries: selectedNodes.map((n) => ({
+        nodeId: n.nodeId,
+        nodePath: n.nodePath,
+        flaggedRuleIds: n.flaggedRuleIds
+      })),
+      conversionRecords: conversionOutput.records,
+      ruleScores
+    });
+    await logger?.logStep({
+      step: "Evaluation",
+      result: `${evaluationOutput.mismatches.length} mismatches, ${evaluationOutput.validatedRules.length} validated`,
+      durationMs: Date.now() - stepStart
+    });
+    stepStart = Date.now();
+    const tuningOutput = runTuningAgent({
+      mismatches: evaluationOutput.mismatches,
+      ruleScores
+    });
+    await logger?.logStep({
+      step: "Tuning",
+      result: `${tuningOutput.adjustments.length} adjustments, ${tuningOutput.newRuleProposals.length} new rule proposals`,
+      durationMs: Date.now() - stepStart
+    });
+    const report = generateCalibrationReport({
+      fileKey,
+      fileName: file.name,
+      analyzedAt: startedAt,
+      nodeCount: analysisResult.nodeCount,
+      issueCount: analysisResult.issues.length,
+      convertedNodeCount: conversionOutput.records.length,
+      skippedNodeCount: conversionOutput.skippedNodeIds.length,
+      scoreReport: analysisOutput.scoreReport,
+      mismatches: evaluationOutput.mismatches,
+      validatedRules: evaluationOutput.validatedRules,
+      adjustments: tuningOutput.adjustments,
+      newRuleProposals: tuningOutput.newRuleProposals
+    });
+    const reportPath = resolve(parsed.outputPath);
+    const reportDir = resolve(parsed.outputPath, "..");
+    if (!existsSync(reportDir)) {
+      mkdirSync(reportDir, { recursive: true });
+    }
+    await writeFile(reportPath, report, "utf-8");
+    await logger?.logSummary({
+      totalDurationMs: Date.now() - pipelineStart,
+      nodesAnalyzed: analysisResult.nodeCount,
+      nodesConverted: conversionOutput.records.length,
+      mismatches: evaluationOutput.mismatches.length,
+      adjustments: tuningOutput.adjustments.length,
+      status: "completed"
+    });
+    return {
+      status: "completed",
+      scoreReport: analysisOutput.scoreReport,
+      nodeIssueSummaries: analysisOutput.nodeIssueSummaries,
+      mismatches: evaluationOutput.mismatches,
+      validatedRules: evaluationOutput.validatedRules,
+      adjustments: tuningOutput.adjustments,
+      newRuleProposals: tuningOutput.newRuleProposals,
+      reportPath,
+      logPath: logger?.getLogPath()
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    await logger?.logSummary({
+      totalDurationMs: Date.now() - pipelineStart,
+      nodesAnalyzed: 0,
+      nodesConverted: 0,
+      mismatches: 0,
+      adjustments: 0,
+      status: `failed: ${errorMessage}`
+    });
+    return {
+      status: "failed",
+      scoreReport: {
+        overall: { score: 0, maxScore: 100, percentage: 0, grade: "F" },
+        byCategory: {},
+        summary: { totalIssues: 0, blocking: 0, risk: 0, missingInfo: 0, suggestion: 0, nodeCount: 0 }
+      },
+      nodeIssueSummaries: [],
+      mismatches: [],
+      validatedRules: [],
+      adjustments: [],
+      newRuleProposals: [],
+      reportPath: parsed.outputPath,
+      error: errorMessage
+    };
+  }
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+
+export { ActivityLogger, AnalysisFileSchema, AnalysisNodeSchema, AnalysisNodeTypeSchema, CATEGORIES, CATEGORY_LABELS, CalibrationConfigSchema, CalibrationStatusSchema, CategorySchema, CategoryScoreSchema, ConfidenceSchema, ConversionRecordSchema, DEPTH_WEIGHT_CATEGORIES, DifficultySchema, FigmaClient, FigmaClientError, FigmaFileLoadError, FigmaUrlInfoSchema, FigmaUrlParseError, IssueSchema, LayoutAlignSchema, LayoutModeSchema, LayoutPositioningSchema, MismatchCaseSchema, MismatchTypeSchema, NewRuleProposalSchema, NodeIssueSummarySchema, RULE_CONFIGS, ReportMetadataSchema, ReportSchema, RuleConfigSchema, RuleDefinitionSchema, RuleEngine, RuleRelatedStruggleSchema, SEVERITY_LABELS, SEVERITY_WEIGHT, SamplingStrategySchema, ScoreAdjustmentSchema, SeveritySchema, UncoveredStruggleSchema, VERSION, absolutePositionInAutoLayout, ambiguousStructure, analyzeFile, buildConversionPrompt, buildFigmaDeepLink, calculateScores, componentPropertyUnused, createRuleEngine, deepNesting, defaultName, defineRule, detachedInstance, emptyFrame, extractRuleScores, fixedSizeInAutoLayout, fixedWidthInResponsiveContext, formatScoreSummary, generateCalibrationReport, getCategoryLabel, getConfigsWithPreset, getRuleOption, getSeverityLabel, gradeToClassName, groupUsage, hardcodeRisk, imageNoPlaceholder, inconsistentNamingConvention, inconsistentSiblingLayoutDirection, inconsistentSpacing, invisibleLayer, loadFigmaFileFromJson, magicNumberSpacing, missingComponent, missingLayoutHint, missingMaxWidth, missingMinWidth, missingResponsiveBehavior, multipleFillColors, nestedInstanceOverride, noAutoLayout, noDevStatus, nonSemanticName, numericSuffixName, overflowHiddenAbuse, parseFigmaJson, parseFigmaUrl, parseMcpMetadataXml, prototypeLinkInDesign, rawColor, rawFont, rawOpacity, rawShadow, ruleRegistry, runAnalysisAgent, runCalibration, runCalibrationAnalyze, runCalibrationEvaluate, runConversionAgent, runEvaluationAgent, runTuningAgent, singleUseComponent, supportsDepthWeight, textTruncationUnhandled, tooLongName, transformFigmaResponse, variantNotUsed, zIndexDependentLayout };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map