@createlex/figma-swiftui-mcp 1.0.7 → 1.0.9

package/companion/mcp-server.mjs

@@ -30,6 +30,8 @@ const BRIDGE_HTTP_URL = process.env.FIGMA_SWIFTUI_BRIDGE_HTTP_URL || 'http://loc
 const BRIDGE_WS_URL = process.env.FIGMA_SWIFTUI_BRIDGE_WS_URL || 'ws://localhost:7765/bridge';
 const REQUEST_TIMEOUT_MS = Number(process.env.FIGMA_SWIFTUI_BRIDGE_TIMEOUT_MS || 30000);
 const AUTH_REVALIDATION_INTERVAL_MS = Number(process.env.FIGMA_SWIFTUI_AUTH_REVALIDATION_MS || (10 * 60 * 1000));
+const RESPONSE_SIZE_CAP = Number(process.env.FIGMA_SWIFTUI_RESPONSE_SIZE_CAP || 102400); // 100 KB default
+const MAX_DIAGNOSTICS = 20;
 
 let bridgeSocket = null;
 let connectPromise = null;
@@ -666,13 +668,13 @@ server.registerTool('write_generated_swiftui_to_xcode', {
   }
 
   return jsonResult({
-    ...result,
+    ...stripImageData(result),
     structName: effectiveStructName,
   });
 });
 
 server.registerTool('write_selection_to_xcode', {
-  description: 'Generate SwiftUI from the connected Figma selection and write it directly into the configured Xcode project.',
+  description: 'Generate SwiftUI from the connected Figma selection, write it into the configured Xcode project, and return refinement hints. After writing, the AI assistant SHOULD automatically apply the returned refinementInstructions to make the generated code adaptive and interactive — replacing raster placeholders with native SwiftUI controls, adding GeometryReader for adaptive layout, and wiring basic interactions.',
   inputSchema: {
     nodeIds: z.array(z.string()).optional().describe('Optional list of Figma node ids. If omitted, uses the current selection'),
     includeOverflow: z.boolean().default(false).describe('Ignore Figma clipping when generating layout'),
@@ -681,6 +683,29 @@ server.registerTool('write_selection_to_xcode', {
   },
 }, async ({ nodeIds, includeOverflow, generationMode, projectPath }) => {
   const targetDir = resolveTargetProjectPath(projectPath);
+
+  // Try hosted analysis first to get refinement hints alongside code
+  let analysisHints = null;
+  try {
+    const analysis = await tryHostedSemanticGeneration({
+      nodeIds,
+      generationMode,
+      includeOverflow,
+      analyze: true,
+    });
+    if (analysis) {
+      analysisHints = {
+        generationHints: analysis.generationHints,
+        manualRefinementHints: analysis.manualRefinementHints,
+        reusableComponents: analysis.reusableComponents,
+        assetExportPlan: analysis.assetExportPlan,
+      };
+    }
+  } catch (err) {
+    // Non-fatal — continue with generation even if analysis fails
+    console.error('[figma-swiftui-mcp] Hosted analysis failed (non-fatal):', err?.message ?? err);
+  }
+
   const generated = await callBridge('generate_swiftui', {
     nodeIds,
     includeOverflow,
@@ -704,14 +729,192 @@ server.registerTool('write_selection_to_xcode', {
     throw new Error(result.results.errors.join(' | ') || 'Failed to write generated selection to Xcode');
   }
 
-  return jsonResult({
-    ...result,
+  // Build refinement instructions from diagnostics and hints
+  const rasterNodes = (generated.diagnostics ?? []).filter(
+    (d) => d.rasterized || d.reason?.toLowerCase().includes('raster')
+  );
+  const refinementInstructions = buildRefinementInstructions({
+    diagnostics: generated.diagnostics ?? [],
+    rasterNodes,
+    analysisHints,
+    structName: effectiveStructName,
+    filePath: result.results?.swiftFile ?? null,
+  });
+
+  return jsonResult(buildCompactResponse({
+    result,
     structName: effectiveStructName,
     selection: generated.selection ?? null,
     diagnostics: generated.diagnostics ?? [],
-  });
+    refinementInstructions,
+    analysisHints,
+  }));
 });
 
+// ---------------------------------------------------------------------------
+// Response-size mitigation helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Remove base64 / svg binary data from any image results.
+ * Files are already on disk — the model only needs names and paths.
+ */
+function stripImageData(obj) {
+  if (!obj || typeof obj !== 'object') return obj;
+
+  // Deep-clone to avoid mutating the original
+  const clone = JSON.parse(JSON.stringify(obj));
+
+  const walk = (node) => {
+    if (Array.isArray(node)) {
+      node.forEach(walk);
+      return;
+    }
+    if (node && typeof node === 'object') {
+      delete node.base64;
+      delete node.svg;
+      delete node.data;
+      for (const value of Object.values(node)) {
+        walk(value);
+      }
+    }
+  };
+
+  walk(clone);
+  return clone;
+}
+
+/**
+ * Cap the diagnostics array, prioritising rasterized nodes first.
+ */
+function capDiagnostics(diagnostics) {
+  if (!Array.isArray(diagnostics) || diagnostics.length <= MAX_DIAGNOSTICS) {
+    return diagnostics;
+  }
+
+  // Sort: rasterized nodes first (most useful for refinement)
+  const sorted = [...diagnostics].sort((a, b) => {
+    const aRaster = a.rasterized || a.reason?.toLowerCase().includes('raster') ? 1 : 0;
+    const bRaster = b.rasterized || b.reason?.toLowerCase().includes('raster') ? 1 : 0;
+    return bRaster - aRaster;
+  });
+
+  const kept = sorted.slice(0, MAX_DIAGNOSTICS);
+  kept.push({
+    _truncated: true,
+    totalCount: diagnostics.length,
+    shownCount: MAX_DIAGNOSTICS,
+    message: `${diagnostics.length - MAX_DIAGNOSTICS} additional diagnostic(s) omitted to reduce response size.`,
+  });
+  return kept;
+}
+
+/**
+ * Build a compact MCP response for write_selection_to_xcode.
+ *
+ * Strategy:
+ *  1. Strip all binary (base64/svg) data from image results.
+ *  2. Cap diagnostics to MAX_DIAGNOSTICS most relevant entries.
+ *  3. Estimate serialised size; if still over RESPONSE_SIZE_CAP,
+ *     compress analysis hints to summary-only.
+ */
+function buildCompactResponse({ result, structName, selection, diagnostics, refinementInstructions, analysisHints }) {
+  const compact = {
+    ...stripImageData(result),
+    structName,
+    selection,
+    diagnostics: capDiagnostics(diagnostics),
+    refinementInstructions,
+    ...(analysisHints ? { analysisHints } : {}),
+  };
+
+  // First size check
+  let serialised = JSON.stringify(compact);
+  if (serialised.length <= RESPONSE_SIZE_CAP) {
+    return compact;
+  }
+
+  // Compress: remove verbose analysis hints, keep only summary-level data
+  if (compact.analysisHints) {
+    const { generationHints, manualRefinementHints, ...rest } = compact.analysisHints;
+    compact.analysisHints = {
+      ...rest,
+      _compressed: true,
+      generationHintCount: generationHints?.interactiveElements?.length ?? 0,
+      manualRefinementHintCount: manualRefinementHints?.length ?? 0,
+    };
+  }
+
+  // Second size check — drop the full Swift code echo if still too large
+  serialised = JSON.stringify(compact);
+  if (serialised.length > RESPONSE_SIZE_CAP && compact.results?.swiftFile) {
+    // The code is already on disk at swiftFile; no need to echo it
+    if (compact.results) {
+      compact.results = { ...compact.results };
+      delete compact.results.code;
+    }
+    compact._responseCapped = true;
+    compact._responseNote = `Response was compressed to stay under ${Math.round(RESPONSE_SIZE_CAP / 1024)}KB. All files were written successfully to disk.`;
+  }
+
+  return compact;
+}
+
+function buildRefinementInstructions({ diagnostics, rasterNodes, analysisHints, structName, filePath }) {
+  const instructions = [];
+
+  // Adaptive layout
+  instructions.push(
+    `Make ${structName} adaptive: replace any fixed .frame(width:height:) on the root body with GeometryReader or .frame(maxWidth: .infinity, maxHeight: .infinity) so the screen fills any device.`
+  );
+
+  // Raster replacements
+  if (rasterNodes.length > 0) {
+    instructions.push(
+      `${rasterNodes.length} element(s) were exported as raster images because Figma could not map them to native SwiftUI. Review these and replace obvious UI controls (buttons, text fields, toggles, tab bars) with native SwiftUI equivalents. Keep actual images/illustrations as Image assets.`
+    );
+  }
+
+  // Hosted analysis hints
+  if (analysisHints?.manualRefinementHints?.length) {
+    for (const hint of analysisHints.manualRefinementHints) {
+      const text = typeof hint === 'string' ? hint : hint.description || hint.message || hint.text || hint.title || null;
+      if (text) {
+        instructions.push(text);
+      }
+    }
+  }
+
+  if (analysisHints?.generationHints?.interactiveElements?.length) {
+    const names = analysisHints.generationHints.interactiveElements
+      .map((e) => e.name || e.nodeId || e.id || '(unnamed)')
+      .filter(Boolean)
+      .join(', ');
+    if (names) {
+      instructions.push(`These elements likely need interaction: ${names}`);
+    }
+  }
+
+  // Reusable components
+  if (analysisHints?.reusableComponents?.length) {
+    const names = analysisHints.reusableComponents
+      .map((c) => c.name || c.componentName || c.id || '(unnamed)')
+      .filter(Boolean)
+      .join(', ');
+    if (names) {
+      instructions.push(
+        `Consider extracting ${analysisHints.reusableComponents.length} reusable component(s): ${names}`
+      );
+    }
+  }
+
+  return {
+    summary: `After writing ${structName}.swift, apply these refinements to make it production-ready:`,
+    steps: instructions,
+    filePath,
+  };
+}
+
 async function shutdownBridgeAndExit(message, exitCode = 1) {
   console.error(message);
   if (authValidationTimer) {

package/companion/package.json

@@ -1,6 +1,6 @@
 {
   "name": "figma-swiftui-companion",
-  "version": "1.0.0",
+  "version": "1.0.9",
   "description": "Local server that writes Figma-generated SwiftUI code and images into an Xcode project",
   "main": "server.js",
   "scripts": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@createlex/figma-swiftui-mcp",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "CreateLex MCP runtime for Figma-to-SwiftUI generation and Xcode export",
   "bin": {
     "figma-swiftui-mcp": "bin/figma-swiftui-mcp.js"