illustrator-mcp-server 1.0.0

package/dist/tools/read/get-groups.js

@@ -0,0 +1,174 @@
+import { z } from 'zod';
+import { executeJsx } from '../../executor/jsx-runner.js';
+const jsxCode = `
+try {
+  var err = preflightChecks();
+  if (err) {
+    writeResultFile(RESULT_PATH, err);
+  } else {
+    var params = readParamsFile(PARAMS_PATH);
+    var coordSystem = (params && params.coordinate_system) ? params.coordinate_system : "artboard-web";
+    var maxDepth = (params && params.depth !== undefined) ? params.depth : 10;
+    var layerName = (params && params.layer_name) ? params.layer_name : null;
+    var doc = app.activeDocument;
+
+    function buildChildTree(container, currentDepth, coordSys) {
+      var children = [];
+      if (currentDepth >= maxDepth) { return children; }
+      for (var i = 0; i < container.pageItems.length; i++) {
+        var child = container.pageItems[i];
+        var childUuid = ensureUUID(child);
+        var childType = getItemType(child);
+        var abIdx = getArtboardIndexForItem(child);
+        var abRect = null;
+        if (abIdx >= 0) { abRect = doc.artboards[abIdx].artboardRect; }
+        var childBounds = getBounds(child, coordSys, abRect);
+        var childInfo = {
+          uuid: childUuid,
+          name: "",
+          type: childType,
+          bounds: childBounds
+        };
+        try { childInfo.name = child.name || ""; } catch(e) {}
+        if (childType === "group" || childType === "compound-path") {
+          try {
+            childInfo.children = buildChildTree(child, currentDepth + 1, coordSys);
+          } catch(e) {
+            childInfo.children = [];
+          }
+        }
+        children.push(childInfo);
+      }
+      return children;
+    }
+
+    var results = [];
+
+    // Determine source container
+    var sourceLayer = null;
+    if (layerName) {
+      for (var li = 0; li < doc.layers.length; li++) {
+        if (doc.layers[li].name === layerName) {
+          sourceLayer = doc.layers[li];
+          break;
+        }
+      }
+      if (!sourceLayer) {
+        writeResultFile(RESULT_PATH, { error: true, message: "Layer not found: " + layerName });
+      }
+    }
+
+    if (layerName && !sourceLayer) {
+      // Already wrote error above; skip rest
+    } else {
+
+    // Collect groups
+    var groupSource = sourceLayer ? sourceLayer.groupItems : doc.groupItems;
+    for (var g = 0; g < groupSource.length; g++) {
+      var group = groupSource[g];
+      var uuid = ensureUUID(group);
+      var zIdx = getZIndex(group);
+      var abIndex = getArtboardIndexForItem(group);
+      var artboardRect = null;
+      if (abIndex >= 0) { artboardRect = doc.artboards[abIndex].artboardRect; }
+      var bounds = getBounds(group, coordSystem, artboardRect);
+
+      var groupType = "group";
+      try {
+        if (group.clipped === true) { groupType = "clipping-mask"; }
+      } catch(e) {}
+
+      var info = {
+        uuid: uuid,
+        zIndex: zIdx,
+        name: "",
+        type: groupType,
+        bounds: bounds,
+        children: []
+      };
+      try { info.name = group.name || ""; } catch(e) {}
+      try {
+        info.children = buildChildTree(group, 0, coordSystem);
+      } catch(e) {
+        info.children = [];
+      }
+      results.push(info);
+    }
+
+    // Collect compound paths
+    var cpSource = sourceLayer ? sourceLayer.compoundPathItems : doc.compoundPathItems;
+    for (var c = 0; c < cpSource.length; c++) {
+      var cp = cpSource[c];
+      var cpUuid = ensureUUID(cp);
+      var cpZIdx = getZIndex(cp);
+      var cpAbIndex = getArtboardIndexForItem(cp);
+      var cpAbRect = null;
+      if (cpAbIndex >= 0) { cpAbRect = doc.artboards[cpAbIndex].artboardRect; }
+      var cpBounds = getBounds(cp, coordSystem, cpAbRect);
+
+      var cpInfo = {
+        uuid: cpUuid,
+        zIndex: cpZIdx,
+        name: "",
+        type: "compound-path",
+        bounds: cpBounds,
+        children: []
+      };
+      try { cpInfo.name = cp.name || ""; } catch(e) {}
+      try {
+        for (var pi = 0; pi < cp.pathItems.length; pi++) {
+          var pathChild = cp.pathItems[pi];
+          var pcUuid = ensureUUID(pathChild);
+          var pcAbIdx = getArtboardIndexForItem(pathChild);
+          var pcAbRect = null;
+          if (pcAbIdx >= 0) { pcAbRect = doc.artboards[pcAbIdx].artboardRect; }
+          var pcBounds = getBounds(pathChild, coordSystem, pcAbRect);
+          cpInfo.children.push({
+            uuid: pcUuid,
+            name: pathChild.name || "",
+            type: "path",
+            bounds: pcBounds
+          });
+        }
+      } catch(e) {}
+      results.push(cpInfo);
+    }
+
+    writeResultFile(RESULT_PATH, {
+      coordinateSystem: coordSystem,
+      count: results.length,
+      groups: results
+    });
+
+    } // end of layerName && !sourceLayer guard
+  }
+} catch (e) {
+  writeResultFile(RESULT_PATH, { error: true, message: e.message, line: e.line });
+}
+`;
+export function register(server) {
+    server.registerTool('get_groups', {
+        title: 'Get Groups',
+        description: 'Get structure of groups, clipping masks, and compound paths',
+        inputSchema: {
+            layer_name: z.string().optional().describe('Filter by layer name (all layers if omitted)'),
+            depth: z.number().optional().default(10).describe('Maximum traversal depth'),
+            coordinate_system: z
+                .enum(['artboard-web', 'document'])
+                .optional()
+                .default('artboard-web'),
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (params) => {
+        const result = await executeJsx(jsxCode, params);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}
+//# sourceMappingURL=get-groups.js.map

package/dist/tools/read/get-groups.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-groups.js","sourceRoot":"","sources":["../../../src/tools/read/get-groups.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE1D,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiJf,CAAC;AAEF,MAAM,UAAU,QAAQ,CAAC,MAAiB;IACxC,MAAM,CAAC,YAAY,CACjB,YAAY,EACZ;QACE,KAAK,EAAE,YAAY;QACnB,WAAW,EAAE,6DAA6D;QAC1E,WAAW,EAAE;YACX,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,8CAA8C,CAAC;YAC1F,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,yBAAyB,CAAC;YAC5E,iBAAiB,EAAE,CAAC;iBACjB,IAAI,CAAC,CAAC,cAAc,EAAE,UAAU,CAAC,CAAC;iBAClC,QAAQ,EAAE;iBACV,OAAO,CAAC,cAAc,CAAC;SAC3B;QACD,WAAW,EAAE;YACX,YAAY,EAAE,IAAI;YAClB,eAAe,EAAE,KAAK;YACtB,cAAc,EAAE,IAAI;YACpB,aAAa,EAAE,KAAK;SACrB;KACF,EACD,KAAK,EAAE,MAAM,EAAE,EAAE;QACf,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACjD,OAAO;YACL,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC;SACnE,CAAC;IACJ,CAAC,CACF,CAAC;AACJ,CAAC"}

package/dist/tools/read/get-guidelines.d.ts

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

package/dist/tools/read/get-guidelines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-guidelines.d.ts","sourceRoot":"","sources":["../../../src/tools/read/get-guidelines.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA8EpE,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA2BhD"}

package/dist/tools/read/get-guidelines.js

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+import { executeJsx } from '../../executor/jsx-runner.js';
+const jsxCode = `
+var err = preflightChecks();
+if (err) {
+  writeResultFile(RESULT_PATH, err);
+} else {
+  try {
+    var params = readParamsFile(PARAMS_PATH);
+    var coordSystem = params.coordinate_system || "artboard-web";
+    var doc = app.activeDocument;
+
+    var artboardRect = null;
+    if (coordSystem === "artboard-web") {
+      artboardRect = getActiveArtboardRect();
+    }
+
+    var horizontal = [];
+    var vertical = [];
+
+    function checkGuide(item) {
+      if (!item.guides) return;
+      var pts = item.pathPoints;
+      if (pts.length < 2) return;
+
+      var allSameY = true;
+      var allSameX = true;
+      var firstY = pts[0].anchor[1];
+      var firstX = pts[0].anchor[0];
+
+      for (var p = 1; p < pts.length; p++) {
+        if (Math.abs(pts[p].anchor[1] - firstY) > 0.01) allSameY = false;
+        if (Math.abs(pts[p].anchor[0] - firstX) > 0.01) allSameX = false;
+      }
+
+      if (allSameY) {
+        var yVal = firstY;
+        if (coordSystem === "artboard-web" && artboardRect) {
+          yVal = -(firstY - artboardRect[1]);
+        }
+        horizontal.push({ position: yVal, locked: item.locked });
+      } else if (allSameX) {
+        var xVal = firstX;
+        if (coordSystem === "artboard-web" && artboardRect) {
+          xVal = firstX - artboardRect[0];
+        }
+        vertical.push({ position: xVal, locked: item.locked });
+      }
+    }
+
+    // 全レイヤーを再帰的に走査してガイドを収集
+    function scanLayer(layer) {
+      for (var i = 0; i < layer.pathItems.length; i++) {
+        checkGuide(layer.pathItems[i]);
+      }
+      for (var j = 0; j < layer.layers.length; j++) {
+        scanLayer(layer.layers[j]);
+      }
+    }
+
+    for (var li = 0; li < doc.layers.length; li++) {
+      scanLayer(doc.layers[li]);
+    }
+
+    writeResultFile(RESULT_PATH, {
+      coordinateSystem: coordSystem,
+      horizontal: horizontal,
+      vertical: vertical,
+      totalCount: horizontal.length + vertical.length
+    });
+  } catch (e) {
+    writeResultFile(RESULT_PATH, { error: true, message: "get_guidelines: " + e.message, line: e.line });
+  }
+}
+`;
+export function register(server) {
+    server.registerTool('get_guidelines', {
+        title: 'Get Guidelines',
+        description: 'Get guide information',
+        inputSchema: {
+            coordinate_system: z
+                .enum(['artboard-web', 'document'])
+                .optional()
+                .default('artboard-web')
+                .describe('Coordinate system (artboard-web: artboard-relative Y-down, document: native Illustrator coordinates)'),
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (params) => {
+        const result = await executeJsx(jsxCode, params);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}
+//# sourceMappingURL=get-guidelines.js.map

package/dist/tools/read/get-guidelines.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-guidelines.js","sourceRoot":"","sources":["../../../src/tools/read/get-guidelines.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE1D,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwEf,CAAC;AAEF,MAAM,UAAU,QAAQ,CAAC,MAAiB;IACxC,MAAM,CAAC,YAAY,CACjB,gBAAgB,EAChB;QACE,KAAK,EAAE,gBAAgB;QACvB,WAAW,EAAE,uBAAuB;QACpC,WAAW,EAAE;YACX,iBAAiB,EAAE,CAAC;iBACjB,IAAI,CAAC,CAAC,cAAc,EAAE,UAAU,CAAC,CAAC;iBAClC,QAAQ,EAAE;iBACV,OAAO,CAAC,cAAc,CAAC;iBACvB,QAAQ,CAAC,sGAAsG,CAAC;SACpH;QACD,WAAW,EAAE;YACX,YAAY,EAAE,IAAI;YAClB,eAAe,EAAE,KAAK;YACtB,cAAc,EAAE,IAAI;YACpB,aAAa,EAAE,KAAK;SACrB;KACF,EACD,KAAK,EAAE,MAAM,EAAE,EAAE;QACf,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACjD,OAAO;YACL,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAe,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC;SAC5E,CAAC;IACJ,CAAC,CACF,CAAC;AACJ,CAAC"}

package/dist/tools/read/get-images.d.ts

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

package/dist/tools/read/get-images.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-images.d.ts","sourceRoot":"","sources":["../../../src/tools/read/get-images.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA2IpE,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA0BhD"}

package/dist/tools/read/get-images.js

@@ -0,0 +1,160 @@
+import { z } from 'zod';
+import { executeJsx } from '../../executor/jsx-runner.js';
+const jsxCode = `
+try {
+  var err = preflightChecks();
+  if (err) {
+    writeResultFile(RESULT_PATH, err);
+  } else {
+    var params = readParamsFile(PARAMS_PATH);
+    var coordSystem = (params && params.coordinate_system) ? params.coordinate_system : "artboard-web";
+    var doc = app.activeDocument;
+    var images = [];
+
+    // Linked images (PlacedItems)
+    for (var i = 0; i < doc.placedItems.length; i++) {
+      var item = doc.placedItems[i];
+      var uuid = ensureUUID(item);
+      var zIdx = getZIndex(item);
+      var abIndex = getArtboardIndexForItem(item);
+      var artboardRect = null;
+      if (abIndex >= 0) {
+        artboardRect = doc.artboards[abIndex].artboardRect;
+      }
+      var bounds = getBounds(item, coordSystem, artboardRect);
+
+      var info = {
+        uuid: uuid,
+        zIndex: zIdx,
+        type: "linked",
+        filePath: "",
+        linkBroken: false,
+        resolution: null,
+        colorSpace: null,
+        pixelWidth: null,
+        pixelHeight: null,
+        artboardIndex: abIndex,
+        bounds: bounds
+      };
+
+      try {
+        info.filePath = item.file.fsName;
+      } catch (e) {
+        info.linkBroken = true;
+      }
+
+      try { info.name = item.name || ""; } catch(e) {}
+
+      images.push(info);
+    }
+
+    // Embedded / raster images (RasterItems)
+    for (var j = 0; j < doc.rasterItems.length; j++) {
+      var rItem = doc.rasterItems[j];
+      var rUuid = ensureUUID(rItem);
+      var rZIdx = getZIndex(rItem);
+      var rAbIndex = getArtboardIndexForItem(rItem);
+      var rArtboardRect = null;
+      if (rAbIndex >= 0) {
+        rArtboardRect = doc.artboards[rAbIndex].artboardRect;
+      }
+      var rBounds = getBounds(rItem, coordSystem, rArtboardRect);
+
+      var rInfo = {
+        uuid: rUuid,
+        zIndex: rZIdx,
+        type: rItem.embedded ? "embedded" : "linked",
+        filePath: "",
+        linkBroken: false,
+        resolution: null,
+        colorSpace: null,
+        pixelWidth: null,
+        pixelHeight: null,
+        artboardIndex: rAbIndex,
+        bounds: rBounds
+      };
+
+      try { rInfo.name = rItem.name || ""; } catch(e) {}
+
+      // colorSpace detection
+      try {
+        var cs = rItem.imageColorSpace;
+        if (cs === ImageColorSpace.RGB) {
+          rInfo.colorSpace = "RGB";
+        } else if (cs === ImageColorSpace.CMYK) {
+          rInfo.colorSpace = "CMYK";
+        } else if (cs === ImageColorSpace.Grayscale) {
+          rInfo.colorSpace = "grayscale";
+        } else {
+          rInfo.colorSpace = "other";
+        }
+      } catch (e) {}
+
+      // pixel dimensions and resolution
+      try {
+        // geometricBounds: [left, top, right, bottom] in points
+        var gb = rItem.geometricBounds;
+        var placedWidthPt = gb[2] - gb[0];
+        var placedHeightPt = -(gb[3] - gb[1]); // top > bottom in AI coords
+
+        // RasterItem exposes matrix; columns/rows not directly available
+        // but we can try to access them
+        try {
+          // Some versions expose these
+          var pw = rItem.artworkKnockout; // dummy access to keep try block
+        } catch(e2) {}
+
+        // Attempt to get pixel size from the item's internal properties
+        try {
+          var m = rItem.matrix;
+          if (m && placedWidthPt > 0 && placedHeightPt > 0) {
+            // matrix.mValueA and mValueD give scale factors from pixels to points
+            var scaleX = Math.abs(m.mValueA);
+            var scaleY = Math.abs(m.mValueD);
+            if (scaleX > 0 && scaleY > 0) {
+              rInfo.pixelWidth = Math.round(placedWidthPt / scaleX);
+              rInfo.pixelHeight = Math.round(placedHeightPt / scaleY);
+              // PPI = pixels / (points / 72)
+              rInfo.resolution = Math.round(rInfo.pixelWidth / (placedWidthPt / 72));
+            }
+          }
+        } catch(e3) {}
+      } catch (e) {}
+
+      images.push(rInfo);
+    }
+
+    writeResultFile(RESULT_PATH, {
+      imageCount: images.length,
+      coordinateSystem: coordSystem,
+      images: images
+    });
+  }
+} catch (e) {
+  writeResultFile(RESULT_PATH, { error: true, message: e.message, line: e.line });
+}
+`;
+export function register(server) {
+    server.registerTool('get_images', {
+        title: 'Get Images',
+        description: 'Get embedded and linked image information',
+        inputSchema: {
+            coordinate_system: z
+                .enum(['artboard-web', 'document'])
+                .optional()
+                .default('artboard-web'),
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (params) => {
+        const result = await executeJsx(jsxCode, params);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}
+//# sourceMappingURL=get-images.js.map

package/dist/tools/read/get-images.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-images.js","sourceRoot":"","sources":["../../../src/tools/read/get-images.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE1D,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqIf,CAAC;AAEF,MAAM,UAAU,QAAQ,CAAC,MAAiB;IACxC,MAAM,CAAC,YAAY,CACjB,YAAY,EACZ;QACE,KAAK,EAAE,YAAY;QACnB,WAAW,EAAE,2CAA2C;QACxD,WAAW,EAAE;YACX,iBAAiB,EAAE,CAAC;iBACjB,IAAI,CAAC,CAAC,cAAc,EAAE,UAAU,CAAC,CAAC;iBAClC,QAAQ,EAAE;iBACV,OAAO,CAAC,cAAc,CAAC;SAC3B;QACD,WAAW,EAAE;YACX,YAAY,EAAE,IAAI;YAClB,eAAe,EAAE,KAAK;YACtB,cAAc,EAAE,IAAI;YACpB,aAAa,EAAE,KAAK;SACrB;KACF,EACD,KAAK,EAAE,MAAM,EAAE,EAAE;QACf,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACjD,OAAO;YACL,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC;SACnE,CAAC;IACJ,CAAC,CACF,CAAC;AACJ,CAAC"}

package/dist/tools/read/get-layers.d.ts

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

package/dist/tools/read/get-layers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-layers.d.ts","sourceRoot":"","sources":["../../../src/tools/read/get-layers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAgFpE,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAqChD"}

package/dist/tools/read/get-layers.js

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+import { executeJsx } from '../../executor/jsx-runner.js';
+const jsxCode = `
+var err = preflightChecks();
+if (err) {
+  writeResultFile(RESULT_PATH, err);
+} else {
+  try {
+    var params = readParamsFile(PARAMS_PATH);
+    var includeSublayers = params.include_sublayers !== false;
+    var includeItems = params.include_items === true;
+    var coordSystem = params.coordinate_system || "artboard-web";
+
+    var doc = app.activeDocument;
+    var artboardRect = null;
+    if (coordSystem === "artboard-web") {
+      artboardRect = getActiveArtboardRect();
+    }
+
+    function extractLayerColor(layer) {
+      try {
+        var c = layer.color;
+        return { r: c.red, g: c.green, b: c.blue };
+      } catch (e) {
+        return null;
+      }
+    }
+
+    function extractItems(layer) {
+      var items = [];
+      for (var i = 0; i < layer.pageItems.length; i++) {
+        var item = layer.pageItems[i];
+        items.push({
+          uuid: ensureUUID(item),
+          name: item.name || "",
+          type: getItemType(item),
+          bounds: getBounds(item, coordSystem, artboardRect)
+        });
+      }
+      return items;
+    }
+
+    function traverseLayer(layer) {
+      var info = {
+        name: layer.name,
+        visible: layer.visible,
+        locked: layer.locked,
+        color: extractLayerColor(layer),
+        item_count: layer.pageItems.length
+      };
+
+      if (includeItems) {
+        info.items = extractItems(layer);
+      }
+
+      if (includeSublayers && layer.layers.length > 0) {
+        var sublayers = [];
+        for (var j = 0; j < layer.layers.length; j++) {
+          sublayers.push(traverseLayer(layer.layers[j]));
+        }
+        info.sublayers = sublayers;
+      }
+
+      return info;
+    }
+
+    var layers = [];
+    for (var i = 0; i < doc.layers.length; i++) {
+      layers.push(traverseLayer(doc.layers[i]));
+    }
+
+    writeResultFile(RESULT_PATH, { layers: layers });
+  } catch (e) {
+    writeResultFile(RESULT_PATH, { error: true, message: "get_layers: " + e.message, line: e.line });
+  }
+}
+`;
+export function register(server) {
+    server.registerTool('get_layers', {
+        title: 'Get Layers',
+        description: 'Get layer structure as a tree',
+        inputSchema: {
+            include_sublayers: z
+                .boolean()
+                .optional()
+                .default(true)
+                .describe('Include sublayers'),
+            include_items: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe('Include items within each layer'),
+            coordinate_system: z
+                .enum(['artboard-web', 'document'])
+                .optional()
+                .default('artboard-web')
+                .describe('Coordinate system (artboard-web: artboard-relative Y-down, document: native Illustrator coordinates)'),
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (params) => {
+        const result = await executeJsx(jsxCode, params);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}
+//# sourceMappingURL=get-layers.js.map

package/dist/tools/read/get-layers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-layers.js","sourceRoot":"","sources":["../../../src/tools/read/get-layers.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE1D,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Ef,CAAC;AAEF,MAAM,UAAU,QAAQ,CAAC,MAAiB;IACxC,MAAM,CAAC,YAAY,CACjB,YAAY,EACZ;QACE,KAAK,EAAE,YAAY;QACnB,WAAW,EAAE,+BAA+B;QAC5C,WAAW,EAAE;YACX,iBAAiB,EAAE,CAAC;iBACjB,OAAO,EAAE;iBACT,QAAQ,EAAE;iBACV,OAAO,CAAC,IAAI,CAAC;iBACb,QAAQ,CAAC,mBAAmB,CAAC;YAChC,aAAa,EAAE,CAAC;iBACb,OAAO,EAAE;iBACT,QAAQ,EAAE;iBACV,OAAO,CAAC,KAAK,CAAC;iBACd,QAAQ,CAAC,iCAAiC,CAAC;YAC9C,iBAAiB,EAAE,CAAC;iBACjB,IAAI,CAAC,CAAC,cAAc,EAAE,UAAU,CAAC,CAAC;iBAClC,QAAQ,EAAE;iBACV,OAAO,CAAC,cAAc,CAAC;iBACvB,QAAQ,CAAC,sGAAsG,CAAC;SACpH;QACD,WAAW,EAAE;YACX,YAAY,EAAE,IAAI;YAClB,eAAe,EAAE,KAAK;YACtB,cAAc,EAAE,IAAI;YACpB,aAAa,EAAE,KAAK;SACrB;KACF,EACD,KAAK,EAAE,MAAM,EAAE,EAAE;QACf,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACjD,OAAO;YACL,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAe,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC;SAC5E,CAAC;IACJ,CAAC,CACF,CAAC;AACJ,CAAC"}

package/dist/tools/read/get-overprint-info.d.ts

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

package/dist/tools/read/get-overprint-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-overprint-info.d.ts","sourceRoot":"","sources":["../../../src/tools/read/get-overprint-info.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAwFpE,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA0BhD"}