@createlex/figgen 1.4.2

package/companion/xcode-writer.cjs

@@ -0,0 +1,516 @@
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const GENERATED_ROOT_DIRNAME = 'FigmaGenerated';
+const GENERATED_LAYOUT_VERSION = 1;
+
+function getConfigDirectory() {
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support', 'FigmaSwiftUICompanion');
+  }
+  return path.join(os.homedir(), '.config', 'FigmaSwiftUICompanion');
+}
+
+function getConfigPath() {
+  return path.join(getConfigDirectory(), 'config.json');
+}
+
+function readConfig() {
+  const configPath = getConfigPath();
+  if (!fs.existsSync(configPath)) {
+    return {};
+  }
+
+  try {
+    const parsed = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function writeConfig(config) {
+  const configPath = getConfigPath();
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+}
+
+function getSavedProjectPath() {
+  const config = readConfig();
+  return typeof config.projectPath === 'string' && config.projectPath.length > 0
+    ? config.projectPath
+    : null;
+}
+
+function setSavedProjectPath(projectPath) {
+  const resolved = resolveWritableProjectPath(projectPath);
+  writeConfig({
+    ...readConfig(),
+    projectPath: resolved,
+    updatedAt: new Date().toISOString(),
+  });
+  return resolved;
+}
+
+function clearSavedProjectPath() {
+  const config = readConfig();
+  delete config.projectPath;
+  config.updatedAt = new Date().toISOString();
+  writeConfig(config);
+}
+
+function loadProjectPath({ explicitPath } = {}) {
+  if (explicitPath) {
+    return resolveWritableProjectPath(explicitPath);
+  }
+
+  if (process.env.FIGMA_SWIFTUI_PROJECT_PATH) {
+    return resolveWritableProjectPath(process.env.FIGMA_SWIFTUI_PROJECT_PATH);
+  }
+
+  return getSavedProjectPath();
+}
+
+function writeSwiftUIScreen({ targetDir, code, structName, images = [], additionalFiles = [] }) {
+  const resolvedTarget = resolveWritableProjectPath(targetDir);
+  const generatedDirs = ensureGeneratedLayout(resolvedTarget);
+  const results = {
+    swiftFile: null,
+    additionalSwiftFiles: [],
+    images: [],
+    manifestFiles: [],
+    generatedRoot: generatedDirs.rootDir,
+    errors: [],
+  };
+
+  if (code && structName) {
+    const swiftPath = path.join(generatedDirs.screensDir, `${structName}.swift`);
+    try {
+      fs.writeFileSync(swiftPath, code, 'utf8');
+      results.swiftFile = swiftPath;
+    } catch (error) {
+      results.errors.push(`Failed to write ${structName}.swift: ${error.message}`);
+    }
+  }
+
+  // Write additional files (DesignTokens.swift, component files, etc.)
+  if (Array.isArray(additionalFiles) && additionalFiles.length > 0) {
+    const componentsDir = path.join(generatedDirs.rootDir, 'Components');
+    for (const extra of additionalFiles) {
+      if (!extra.name || !extra.code) continue;
+      let destDir;
+      if (extra.dir === 'shared') {
+        destDir = generatedDirs.rootDir;
+      } else if (extra.dir === 'components') {
+        try {
+          fs.mkdirSync(componentsDir, { recursive: true });
+        } catch {
+          // ignore
+        }
+        destDir = componentsDir;
+      } else {
+        destDir = generatedDirs.screensDir;
+      }
+      const filePath = path.join(destDir, extra.name);
+      try {
+        fs.writeFileSync(filePath, extra.code, 'utf8');
+        results.additionalSwiftFiles.push(filePath);
+      } catch (error) {
+        results.errors.push(`Failed to write ${extra.name}: ${error.message}`);
+      }
+    }
+  }
+
+  if (Array.isArray(images) && images.length > 0) {
+    const assetResult = writeAssetCatalogEntries({
+      targetDir: resolvedTarget,
+      assets: images.map((image) => ({
+        name: image.name,
+        format: image.format || 'png',
+        base64: image.base64,
+        svg: image.svg,
+      })),
+    });
+    results.images.push(...assetResult.files);
+    results.errors.push(...assetResult.errors);
+  }
+
+  if (code && structName) {
+    try {
+      const manifestFiles = writeGeneratedManifest(resolvedTarget, generatedDirs, {
+        structName,
+        code,
+        swiftFile: results.swiftFile,
+        images: Array.isArray(images) ? images : [],
+      });
+      results.manifestFiles.push(...manifestFiles);
+    } catch (error) {
+      results.errors.push(`Failed to update generated manifest: ${error.message}`);
+    }
+  }
+
+  return {
+    ok: results.errors.length === 0,
+    results,
+    projectPath: resolvedTarget,
+    generatedRoot: generatedDirs.rootDir,
+    layoutVersion: GENERATED_LAYOUT_VERSION,
+  };
+}
+
+function writeAssetCatalogEntries({ targetDir, assets = [] }) {
+  const resolvedTarget = resolveWritableProjectPath(targetDir);
+  const xcassetsDir = findOrCreateXcassets(resolvedTarget);
+  const files = [];
+  const errors = [];
+
+  for (const asset of assets) {
+    try {
+      const imagesetDir = path.join(xcassetsDir, `${asset.name}.imageset`);
+      fs.mkdirSync(imagesetDir, { recursive: true });
+
+      if (asset.format === 'svg') {
+        const svgPath = path.join(imagesetDir, `${asset.name}.svg`);
+        fs.writeFileSync(svgPath, asset.svg, 'utf8');
+        fs.writeFileSync(
+          path.join(imagesetDir, 'Contents.json'),
+          JSON.stringify({
+            images: [
+              { idiom: 'universal', filename: `${asset.name}.svg` },
+            ],
+            properties: {
+              'preserves-vector-representation': true,
+            },
+            info: { version: 1, author: 'figma-swiftui-plugin' },
+          }, null, 2),
+          'utf8'
+        );
+        files.push(svgPath);
+        continue;
+      }
+
+      const pngPath = path.join(imagesetDir, `${asset.name}.png`);
+      const pngBuffer = Buffer.from(asset.base64, 'base64');
+      fs.writeFileSync(pngPath, pngBuffer);
+      fs.writeFileSync(
+        path.join(imagesetDir, 'Contents.json'),
+        JSON.stringify({
+          images: [
+            { idiom: 'universal', scale: '1x' },
+            { idiom: 'universal', scale: '2x', filename: `${asset.name}.png` },
+            { idiom: 'universal', scale: '3x' },
+          ],
+          info: { version: 1, author: 'figma-swiftui-plugin' },
+        }, null, 2),
+        'utf8'
+      );
+      files.push(pngPath);
+    } catch (error) {
+      errors.push(`Failed to write image ${asset.name}: ${error.message}`);
+    }
+  }
+
+  return {
+    ok: errors.length === 0,
+    xcassetsDir,
+    files,
+    errors,
+  };
+}
+
+function inferStructName({ structName, code, selectionNames = [] }) {
+  if (structName && typeof structName === 'string') {
+    return sanitizeName(structName) || 'GeneratedView';
+  }
+
+  if (typeof code === 'string') {
+    const match = code.match(/struct\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*View\b/);
+    if (match?.[1]) {
+      return match[1];
+    }
+  }
+
+  if (selectionNames.length > 0) {
+    return sanitizeName(selectionNames[0]) || 'GeneratedView';
+  }
+
+  return 'GeneratedView';
+}
+
+function sanitizeName(name) {
+  return String(name)
+    .replace(/[^a-zA-Z0-9 ]/g, '')
+    .replace(/\s+(.)/g, (_, c) => c.toUpperCase())
+    .replace(/^\w/, c => c.toUpperCase())
+    .trim();
+}
+
+function findOrCreateXcassets(targetDir) {
+  const entries = fs.readdirSync(targetDir);
+  const existing = entries.find((entry) => entry.endsWith('.xcassets'));
+  if (existing) {
+    return path.join(targetDir, existing);
+  }
+
+  const newDir = path.join(targetDir, 'Assets.xcassets');
+  fs.mkdirSync(newDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(newDir, 'Contents.json'),
+    JSON.stringify({ info: { version: 1, author: 'xcode' } }, null, 2),
+    'utf8'
+  );
+  return newDir;
+}
+
+function ensureGeneratedLayout(targetDir) {
+  const rootDir = path.join(targetDir, GENERATED_ROOT_DIRNAME);
+  const screensDir = path.join(rootDir, 'Screens');
+  const componentsDir = path.join(rootDir, 'Components');
+  const manifestDir = path.join(rootDir, 'Manifest');
+
+  [rootDir, screensDir, componentsDir, manifestDir].forEach((dirPath) => {
+    fs.mkdirSync(dirPath, { recursive: true });
+  });
+
+  return { rootDir, screensDir, componentsDir, manifestDir };
+}
+
+function writeGeneratedManifest(targetDir, generatedDirs, payload) {
+  const { structName, code, swiftFile, images } = payload;
+  const generatedAt = new Date().toISOString();
+  const codeHash = crypto.createHash('sha256').update(code, 'utf8').digest('hex');
+  const screenManifestPath = path.join(generatedDirs.manifestDir, `${structName}.json`);
+  const indexManifestPath = path.join(generatedDirs.manifestDir, 'index.json');
+  const xcassetsDir = findOrCreateXcassets(targetDir);
+
+  const screenManifest = {
+    schemaVersion: GENERATED_LAYOUT_VERSION,
+    generatedAt,
+    structName,
+    codeHash,
+    screenFile: swiftFile ? toProjectRelativePath(targetDir, swiftFile) : null,
+    componentFiles: [],
+    assetCatalog: toProjectRelativePath(targetDir, xcassetsDir),
+    assets: images.map((image) => ({
+      name: image.name,
+      imageset: `Assets.xcassets/${image.name}.imageset`,
+    })),
+  };
+
+  fs.writeFileSync(screenManifestPath, JSON.stringify(screenManifest, null, 2), 'utf8');
+
+  let indexManifest = {
+    schemaVersion: GENERATED_LAYOUT_VERSION,
+    updatedAt: generatedAt,
+    generatedRoot: GENERATED_ROOT_DIRNAME,
+    projectPath: targetDir,
+    screens: [],
+  };
+
+  if (fs.existsSync(indexManifestPath)) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(indexManifestPath, 'utf8'));
+      if (parsed && typeof parsed === 'object' && Array.isArray(parsed.screens)) {
+        indexManifest = {
+          ...indexManifest,
+          ...parsed,
+          screens: parsed.screens,
+        };
+      }
+    } catch {
+      // Ignore invalid existing manifest; it will be replaced.
+    }
+  }
+
+  indexManifest.updatedAt = generatedAt;
+  indexManifest.projectPath = targetDir;
+  indexManifest.generatedRoot = GENERATED_ROOT_DIRNAME;
+  indexManifest.screens = [
+    ...indexManifest.screens.filter((screen) => screen.structName !== structName),
+    {
+      structName,
+      generatedAt,
+      codeHash,
+      screenFile: screenManifest.screenFile,
+      manifestFile: toProjectRelativePath(targetDir, screenManifestPath),
+      assetCount: screenManifest.assets.length,
+      assets: screenManifest.assets.map((asset) => asset.name),
+    },
+  ].sort((left, right) => left.structName.localeCompare(right.structName));
+
+  fs.writeFileSync(indexManifestPath, JSON.stringify(indexManifest, null, 2), 'utf8');
+  return [screenManifestPath, indexManifestPath];
+}
+
+function toProjectRelativePath(targetDir, filePath) {
+  return path.relative(targetDir, filePath).replace(/\\/g, '/');
+}
+
+function resolveWritableProjectPath(inputPath) {
+  const resolved = path.resolve(inputPath);
+  if (!fs.existsSync(resolved)) {
+    return resolved;
+  }
+
+  const stats = fs.statSync(resolved);
+  if (!stats.isDirectory()) {
+    const parentDir = path.dirname(resolved);
+    const projectBaseName = path.basename(resolved, path.extname(resolved));
+    const matchingChild = path.join(parentDir, projectBaseName);
+    if (looksLikeSourceDirectory(matchingChild)) {
+      return matchingChild;
+    }
+    return parentDir;
+  }
+
+  const localProjectNames = getLocalProjectNames(resolved);
+  const currentScore = scoreSourceDirectory(resolved);
+
+  const childDirs = fs.readdirSync(resolved, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && !entry.name.endsWith('.xcodeproj') && !entry.name.endsWith('.xcworkspace'))
+    .map((entry) => path.join(resolved, entry.name));
+
+  const sourceCandidates = childDirs
+    .filter(looksLikeSourceDirectory)
+    .sort((left, right) => scoreSourceDirectory(right, localProjectNames) - scoreSourceDirectory(left, localProjectNames));
+
+  if (sourceCandidates.length > 0) {
+    const bestChild = sourceCandidates[0];
+    const bestChildScore = scoreSourceDirectory(bestChild, localProjectNames);
+    const childName = path.basename(bestChild);
+
+    if (
+      localProjectNames.has(childName) ||
+      bestChildScore > currentScore ||
+      !looksLikeSourceDirectory(resolved)
+    ) {
+      return bestChild;
+    }
+  }
+
+  if (looksLikeSourceDirectory(resolved)) {
+    return resolved;
+  }
+
+  return resolved;
+}
+
+function getLocalProjectNames(dirPath) {
+  const projectNames = new Set();
+  for (const entry of fs.readdirSync(dirPath, { withFileTypes: true })) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    if (entry.name.endsWith('.xcodeproj') || entry.name.endsWith('.xcworkspace')) {
+      projectNames.add(path.basename(entry.name, path.extname(entry.name)));
+    }
+  }
+  return projectNames;
+}
+
+function looksLikeSourceDirectory(dirPath) {
+  if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) {
+    return false;
+  }
+
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  return entries.some((entry) => entry.isFile() && entry.name.endsWith('.swift'))
+    || entries.some((entry) => entry.isDirectory() && entry.name.endsWith('.xcassets'));
+}
+
+function scoreSourceDirectory(dirPath, preferredNames = new Set()) {
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  let score = 0;
+
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith('.swift')) {
+      score += 2;
+      if (entry.name.endsWith('App.swift')) {
+        score += 3;
+      }
+    }
+    if (entry.isDirectory() && entry.name.endsWith('.xcassets')) {
+      score += 4;
+    }
+  }
+
+  if (preferredNames.has(path.basename(dirPath))) {
+    score += 10;
+  }
+
+  return score;
+}
+
+/**
+ * Write multiple screens from a single generation batch.
+ * Shares DesignTokens.swift and Components across all screens.
+ *
+ * @param {Object} opts
+ * @param {string} opts.targetDir - Xcode source folder
+ * @param {Array<{structName: string, code: string, images?: Array}>} opts.screens
+ * @param {string|null} opts.designTokensCode - Shared DesignTokens.swift
+ * @param {Array<{name: string, code: string}>} opts.componentFiles - Shared components
+ * @returns {{ok: boolean, screens: Array, errors: string[]}}
+ */
+function writeMultiScreenProject({ targetDir, screens = [], designTokensCode = null, componentFiles = [] }) {
+  const allErrors = [];
+  const screenResults = [];
+
+  // Build shared additional files list
+  const sharedFiles = [];
+  if (designTokensCode) {
+    sharedFiles.push({ name: 'DesignTokens.swift', code: designTokensCode, dir: 'shared' });
+  }
+  for (const comp of componentFiles) {
+    sharedFiles.push({ name: comp.name, code: comp.code, dir: 'components' });
+  }
+
+  for (let i = 0; i < screens.length; i++) {
+    const screen = screens[i];
+    // Only include shared files on the first screen write to avoid duplicates
+    const additionalFiles = i === 0 ? sharedFiles : [];
+
+    const result = writeSwiftUIScreen({
+      targetDir,
+      code: screen.code,
+      structName: screen.structName,
+      images: Array.isArray(screen.images) ? screen.images : [],
+      additionalFiles,
+    });
+
+    screenResults.push({
+      structName: screen.structName,
+      ok: result.ok,
+      swiftFile: result.results?.swiftFile ?? null,
+      imageCount: (screen.images ?? []).length,
+    });
+
+    if (!result.ok) {
+      allErrors.push(...result.results.errors);
+    }
+  }
+
+  return {
+    ok: allErrors.length === 0,
+    screens: screenResults,
+    errors: allErrors,
+    projectPath: targetDir,
+  };
+}
+
+module.exports = {
+  GENERATED_ROOT_DIRNAME,
+  GENERATED_LAYOUT_VERSION,
+  clearSavedProjectPath,
+  getConfigPath,
+  getSavedProjectPath,
+  inferStructName,
+  loadProjectPath,
+  resolveWritableProjectPath,
+  setSavedProjectPath,
+  writeAssetCatalogEntries,
+  writeMultiScreenProject,
+  writeSwiftUIScreen,
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@createlex/figgen",
+  "version": "1.4.2",
+  "description": "CreateLex MCP runtime for Figma-to-SwiftUI generation and Xcode export",
+  "bin": {
+    "figgen": "bin/figgen.js"
+  },
+  "files": [
+    "bin/",
+    "companion/bridge-server.cjs",
+    "companion/createlex-auth.cjs",
+    "companion/local-llm-generator.cjs",
+    "companion/login.mjs",
+    "companion/mcp-server.mjs",
+    "companion/package.json",
+    "companion/server.js",
+    "companion/setup.cjs",
+    "companion/xcode-writer.cjs",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "login": "node bin/figma-swiftui-mcp.js login",
+    "start": "node bin/figma-swiftui-mcp.js start",
+    "watch": "tsc --watch",
+    "test:bridge-smoke": "node ../tests/mcp/figma_plugin_swiftui_bridge_smoke.mjs",
+    "test:high-fidelity-smoke": "node ../tests/mcp/figma_plugin_swiftui_high_fidelity_smoke.mjs",
+    "start:companion:mcp": "node bin/figma-swiftui-mcp.js start"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.28.0",
+    "cors": "^2.8.5",
+    "express": "^4.18.0",
+    "ws": "^8.20.0",
+    "zod": "^4.3.6"
+  },
+  "optionalDependencies": {
+    "@anthropic-ai/sdk": "^0.52.0"
+  },
+  "devDependencies": {
+    "@figma/plugin-typings": "*",
+    "typescript": "^5.4.0"
+  }
+}