illustrator-mcp-server 1.0.0

package/dist/tools/read/get-overprint-info.js

@@ -0,0 +1,109 @@
+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;
+
+    function getParentLayerName(item) {
+      var current = item.parent;
+      while (current) {
+        if (current.typename === "Layer") return current.name;
+        current = current.parent;
+      }
+      return "";
+    }
+
+    function collectOverprintItems(container, results) {
+      for (var i = 0; i < container.pageItems.length; i++) {
+        var item = container.pageItems[i];
+        try {
+          if (item.typename === "GroupItem") {
+            collectOverprintItems(item, results);
+          } else if (item.typename === "PathItem") {
+            var fillOP = false;
+            var strokeOP = false;
+            try { fillOP = item.fillOverprint; } catch(e2) {}
+            try { strokeOP = item.strokeOverprint; } catch(e2) {}
+            if (fillOP || strokeOP) {
+              var uuid = ensureUUID(item);
+              var objName = "";
+              try { objName = item.name || ""; } catch(e2) {}
+              results.push({
+                uuid: uuid,
+                objectName: objName,
+                fillOverprint: fillOP,
+                strokeOverprint: strokeOP,
+                layerName: getParentLayerName(item)
+              });
+            }
+          } else if (item.typename === "CompoundPathItem") {
+            for (var j = 0; j < item.pathItems.length; j++) {
+              var pathItem = item.pathItems[j];
+              var fillOP2 = false;
+              var strokeOP2 = false;
+              try { fillOP2 = pathItem.fillOverprint; } catch(e2) {}
+              try { strokeOP2 = pathItem.strokeOverprint; } catch(e2) {}
+              if (fillOP2 || strokeOP2) {
+                var uuid2 = ensureUUID(pathItem);
+                var objName2 = "";
+                try { objName2 = pathItem.name || ""; } catch(e2) {}
+                results.push({
+                  uuid: uuid2,
+                  objectName: objName2,
+                  fillOverprint: fillOP2,
+                  strokeOverprint: strokeOP2,
+                  layerName: getParentLayerName(item)
+                });
+              }
+            }
+          }
+        } catch(e) {}
+      }
+    }
+
+    var results = [];
+
+    for (var layerIdx = 0; layerIdx < doc.layers.length; layerIdx++) {
+      collectOverprintItems(doc.layers[layerIdx], results);
+    }
+
+    writeResultFile(RESULT_PATH, {
+      coordinateSystem: coordSystem,
+      overprintCount: results.length,
+      items: results
+    });
+  }
+} catch (e) {
+  writeResultFile(RESULT_PATH, { error: true, message: e.message, line: e.line });
+}
+`;
+export function register(server) {
+    server.registerTool('get_overprint_info', {
+        title: 'Get Overprint Info',
+        description: 'Get overprint settings',
+        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-overprint-info.js.map

package/dist/tools/read/get-overprint-info.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-overprint-info.js","sourceRoot":"","sources":["../../../src/tools/read/get-overprint-info.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE1D,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkFf,CAAC;AAEF,MAAM,UAAU,QAAQ,CAAC,MAAiB;IACxC,MAAM,CAAC,YAAY,CACjB,oBAAoB,EACpB;QACE,KAAK,EAAE,oBAAoB;QAC3B,WAAW,EAAE,wBAAwB;QACrC,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-path-items.d.ts

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

package/dist/tools/read/get-path-items.d.ts.map

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

package/dist/tools/read/get-path-items.js

@@ -0,0 +1,252 @@
+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 includePoints = params.include_points === true;
+    var selectionOnly = params.selection_only === true;
+    var layerName = params.layer_name || null;
+    var doc = app.activeDocument;
+
+    function getStrokeCapStr(cap) {
+      try {
+        if (cap === StrokeCap.BUTTENDCAP) return "butt";
+        if (cap === StrokeCap.ROUNDENDCAP) return "round";
+        if (cap === StrokeCap.PROJECTINGENDCAP) return "projecting";
+      } catch (e) {}
+      return null;
+    }
+
+    function getStrokeJoinStr(join) {
+      try {
+        if (join === StrokeJoin.MITERENDJOIN) return "miter";
+        if (join === StrokeJoin.ROUNDENDJOIN) return "round";
+        if (join === StrokeJoin.BEVELENDJOIN) return "bevel";
+      } catch (e) {}
+      return null;
+    }
+
+    function getStrokeDashes(item) {
+      try {
+        var dashes = item.strokeDashes;
+        if (dashes && dashes.length > 0) {
+          var arr = [];
+          for (var d = 0; d < dashes.length; d++) {
+            arr.push(dashes[d]);
+          }
+          return arr;
+        }
+      } catch (e) {}
+      return [];
+    }
+
+    function convertPoint(pt, artboardRect) {
+      var pos = { x: pt.anchor[0], y: pt.anchor[1] };
+      var left = { x: pt.leftDirection[0], y: pt.leftDirection[1] };
+      var right = { x: pt.rightDirection[0], y: pt.rightDirection[1] };
+
+      if (coordSystem === "artboard-web" && artboardRect) {
+        var abLeft = artboardRect[0];
+        var abTop = artboardRect[1];
+        pos.x = pos.x - abLeft;
+        pos.y = -(pos.y - abTop);
+        left.x = left.x - abLeft;
+        left.y = -(left.y - abTop);
+        right.x = right.x - abLeft;
+        right.y = -(right.y - abTop);
+      }
+
+      var pointType = "corner";
+      try {
+        if (pt.pointType === PointType.SMOOTH) pointType = "smooth";
+        else if (pt.pointType === PointType.CORNER) pointType = "corner";
+      } catch (e) {}
+
+      return {
+        position: pos,
+        leftDirection: left,
+        rightDirection: right,
+        pointType: pointType
+      };
+    }
+
+    function extractPathInfo(item) {
+      var abIndex = getArtboardIndexForItem(item);
+      var artboardRect = null;
+      if (abIndex >= 0) {
+        artboardRect = doc.artboards[abIndex].artboardRect;
+      }
+
+      var bounds = getBounds(item, coordSystem, artboardRect);
+      var uuid = ensureUUID(item);
+      var zIdx = getZIndex(item);
+
+      var info = {
+        uuid: uuid,
+        zIndex: zIdx,
+        name: "",
+        closed: false,
+        artboardIndex: abIndex,
+        bounds: bounds,
+        fill: null,
+        stroke: null,
+        opacity: 100,
+        cornerRadius: null,
+        transform: {
+          rotation: null,
+          scaleX: null,
+          scaleY: null,
+          reflect: null
+        }
+      };
+
+      try { info.name = item.name || ""; } catch (e) {}
+      try { info.closed = item.closed; } catch (e) {}
+      try { info.opacity = item.opacity; } catch (e) {}
+
+      // fill
+      try {
+        if (item.filled) {
+          info.fill = {
+            color: colorToObject(item.fillColor),
+            opacity: item.opacity
+          };
+        } else {
+          info.fill = { color: { type: "none" }, opacity: 100 };
+        }
+      } catch (e) {
+        info.fill = { color: { type: "none" }, opacity: 100 };
+      }
+
+      // stroke
+      try {
+        if (item.stroked) {
+          info.stroke = {
+            color: colorToObject(item.strokeColor),
+            width: item.strokeWidth,
+            cap: getStrokeCapStr(item.strokeCap),
+            join: getStrokeJoinStr(item.strokeJoin),
+            dashPattern: getStrokeDashes(item)
+          };
+        } else {
+          info.stroke = null;
+        }
+      } catch (e) {
+        info.stroke = null;
+      }
+
+      // anchor points
+      if (includePoints) {
+        try {
+          var points = [];
+          for (var p = 0; p < item.pathPoints.length; p++) {
+            points.push(convertPoint(item.pathPoints[p], artboardRect));
+          }
+          info.anchorPoints = points;
+        } catch (e) {
+          info.anchorPoints = [];
+        }
+      }
+
+      return info;
+    }
+
+    var pathItems = [];
+    var hasError = false;
+
+    if (selectionOnly) {
+      var sel = doc.selection;
+      if (sel && sel.length > 0) {
+        for (var i = 0; i < sel.length; i++) {
+          if (sel[i].typename === "PathItem" && !sel[i].guides) {
+            pathItems.push(extractPathInfo(sel[i]));
+          }
+        }
+      }
+    } else if (layerName) {
+      var targetLayer = null;
+      for (var li = 0; li < doc.layers.length; li++) {
+        if (doc.layers[li].name === layerName) {
+          targetLayer = doc.layers[li];
+          break;
+        }
+      }
+      if (!targetLayer) {
+        hasError = true;
+        writeResultFile(RESULT_PATH, {
+          error: true,
+          message: "Layer '" + layerName + "' not found"
+        });
+      } else {
+        for (var j = 0; j < targetLayer.pathItems.length; j++) {
+          var pi = targetLayer.pathItems[j];
+          if (!pi.guides) {
+            pathItems.push(extractPathInfo(pi));
+          }
+        }
+      }
+    } else {
+      for (var k = 0; k < doc.pathItems.length; k++) {
+        var pk = doc.pathItems[k];
+        if (!pk.guides) {
+          pathItems.push(extractPathInfo(pk));
+        }
+      }
+    }
+
+    if (!hasError) {
+      writeResultFile(RESULT_PATH, {
+        coordinateSystem: coordSystem,
+        count: pathItems.length,
+        pathItems: pathItems
+      });
+    }
+  } catch (e) {
+    writeResultFile(RESULT_PATH, { error: true, message: "get_path_items: " + e.message, line: e.line });
+  }
+}
+`;
+export function register(server) {
+    server.registerTool('get_path_items', {
+        title: 'Get Path Items',
+        description: 'Get path and shape data',
+        inputSchema: {
+            layer_name: z
+                .string()
+                .optional()
+                .describe('Filter by layer name'),
+            include_points: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe('Include anchor point details'),
+            selection_only: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe('Get selected paths only'),
+            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-path-items.js.map

package/dist/tools/read/get-path-items.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-path-items.js","sourceRoot":"","sources":["../../../src/tools/read/get-path-items.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE1D,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkNf,CAAC;AAEF,MAAM,UAAU,QAAQ,CAAC,MAAiB;IACxC,MAAM,CAAC,YAAY,CACjB,gBAAgB,EAChB;QACE,KAAK,EAAE,gBAAgB;QACvB,WAAW,EAAE,yBAAyB;QACtC,WAAW,EAAE;YACX,UAAU,EAAE,CAAC;iBACV,MAAM,EAAE;iBACR,QAAQ,EAAE;iBACV,QAAQ,CAAC,sBAAsB,CAAC;YACnC,cAAc,EAAE,CAAC;iBACd,OAAO,EAAE;iBACT,QAAQ,EAAE;iBACV,OAAO,CAAC,KAAK,CAAC;iBACd,QAAQ,CAAC,8BAA8B,CAAC;YAC3C,cAAc,EAAE,CAAC;iBACd,OAAO,EAAE;iBACT,QAAQ,EAAE;iBACV,OAAO,CAAC,KAAK,CAAC;iBACd,QAAQ,CAAC,yBAAyB,CAAC;YACtC,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-selection.d.ts

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

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

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

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

@@ -0,0 +1,177 @@
+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 sel = doc.selection;
+
+    if (!sel || sel.length === 0) {
+      writeResultFile(RESULT_PATH, { selectionCount: 0, items: [] });
+    } else {
+      var items = [];
+
+      for (var i = 0; i < sel.length; i++) {
+        var item = sel[i];
+        var uuid = ensureUUID(item);
+        var zIdx = getZIndex(item);
+        var itemType = getItemType(item);
+
+        // artboard detection for coordinate conversion
+        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: itemType,
+          name: "",
+          artboardIndex: abIndex,
+          bounds: bounds,
+          locked: false,
+          hidden: false,
+          opacity: 100
+        };
+
+        try { info.name = item.name || ""; } catch(e) {}
+        try { info.locked = item.locked; } catch(e) {}
+        try { info.hidden = item.hidden; } catch(e) {}
+        try { info.opacity = item.opacity; } catch(e) {}
+
+        // type-specific attributes
+        if (itemType === "text") {
+          try {
+            info.contents = item.contents;
+          } catch(e) {
+            info.contents = "";
+          }
+          try {
+            if (item.textRanges.length > 0) {
+              var firstRange = item.textRanges[0];
+              info.fontFamily = firstRange.characterAttributes.textFont.family;
+              info.fontSize = firstRange.characterAttributes.size;
+            }
+          } catch(e) {}
+          try {
+            var kind = item.kind;
+            if (kind === TextType.POINTTEXT) {
+              info.textKind = "point";
+            } else if (kind === TextType.AREATEXT) {
+              info.textKind = "area";
+            } else if (kind === TextType.PATHTEXT) {
+              info.textKind = "path";
+            }
+          } catch(e) {}
+        }
+
+        if (itemType === "path") {
+          try {
+            info.filled = item.filled;
+            if (item.filled) {
+              info.fillColor = colorToObject(item.fillColor);
+            }
+          } catch(e) {}
+          try {
+            info.stroked = item.stroked;
+            if (item.stroked) {
+              info.strokeColor = colorToObject(item.strokeColor);
+              info.strokeWidth = item.strokeWidth;
+            }
+          } catch(e) {}
+          try {
+            info.closed = item.closed;
+          } catch(e) {}
+        }
+
+        if (itemType === "compound-path") {
+          try {
+            if (item.pathItems.length > 0) {
+              var firstPath = item.pathItems[0];
+              info.filled = firstPath.filled;
+              if (firstPath.filled) {
+                info.fillColor = colorToObject(firstPath.fillColor);
+              }
+              info.stroked = firstPath.stroked;
+              if (firstPath.stroked) {
+                info.strokeColor = colorToObject(firstPath.strokeColor);
+                info.strokeWidth = firstPath.strokeWidth;
+              }
+            }
+          } catch(e) {}
+        }
+
+        if (itemType === "image") {
+          try {
+            if (item.typename === "PlacedItem") {
+              info.imageType = "linked";
+              try {
+                info.filePath = item.file.fsName;
+              } catch(e) {
+                info.filePath = "";
+              }
+            } else if (item.typename === "RasterItem") {
+              info.imageType = item.embedded ? "embedded" : "linked";
+            }
+          } catch(e) {}
+        }
+
+        if (itemType === "group") {
+          try {
+            info.childCount = item.pageItems.length;
+          } catch(e) {}
+        }
+
+        if (itemType === "symbol") {
+          try {
+            info.symbolName = item.symbol.name;
+          } catch(e) {}
+        }
+
+        items.push(info);
+      }
+
+      writeResultFile(RESULT_PATH, {
+        selectionCount: sel.length,
+        coordinateSystem: coordSystem,
+        items: items
+      });
+    }
+  }
+} catch (e) {
+  writeResultFile(RESULT_PATH, { error: true, message: e.message, line: e.line });
+}
+`;
+export function register(server) {
+    server.registerTool('get_selection', {
+        title: 'Get Selection',
+        description: 'Get detailed information about the currently selected objects',
+        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-selection.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-selection.js","sourceRoot":"","sources":["../../../src/tools/read/get-selection.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE1D,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsJf,CAAC;AAEF,MAAM,UAAU,QAAQ,CAAC,MAAiB;IACxC,MAAM,CAAC,YAAY,CACjB,eAAe,EACf;QACE,KAAK,EAAE,eAAe;QACtB,WAAW,EAAE,+DAA+D;QAC5E,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-symbols.d.ts

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

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

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

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

@@ -0,0 +1,101 @@
+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;
+
+    // Build instance count map by symbol name
+    var instanceCountMap = {};
+    for (var i = 0; i < doc.symbolItems.length; i++) {
+      var si = doc.symbolItems[i];
+      try {
+        var sName = si.symbol.name;
+        if (instanceCountMap[sName]) {
+          instanceCountMap[sName] = instanceCountMap[sName] + 1;
+        } else {
+          instanceCountMap[sName] = 1;
+        }
+      } catch (e) {}
+    }
+
+    // Symbol definitions
+    var definitions = [];
+    for (var d = 0; d < doc.symbols.length; d++) {
+      var sym = doc.symbols[d];
+      var defName = "";
+      try { defName = sym.name; } catch(e) {}
+      definitions.push({
+        name: defName,
+        instanceCount: instanceCountMap[defName] || 0
+      });
+    }
+
+    // Symbol instances
+    var instances = [];
+    for (var k = 0; k < doc.symbolItems.length; k++) {
+      var sItem = doc.symbolItems[k];
+      var uuid = ensureUUID(sItem);
+      var zIdx = getZIndex(sItem);
+      var abIndex = getArtboardIndexForItem(sItem);
+      var artboardRect = null;
+      if (abIndex >= 0) {
+        artboardRect = doc.artboards[abIndex].artboardRect;
+      }
+      var bounds = getBounds(sItem, coordSystem, artboardRect);
+
+      var instInfo = {
+        uuid: uuid,
+        zIndex: zIdx,
+        symbolName: "",
+        artboardIndex: abIndex,
+        bounds: bounds
+      };
+
+      try { instInfo.symbolName = sItem.symbol.name; } catch(e) {}
+      try { instInfo.name = sItem.name || ""; } catch(e) {}
+
+      instances.push(instInfo);
+    }
+
+    writeResultFile(RESULT_PATH, {
+      definitionCount: definitions.length,
+      instanceCount: instances.length,
+      coordinateSystem: coordSystem,
+      definitions: definitions,
+      instances: instances
+    });
+  }
+} catch (e) {
+  writeResultFile(RESULT_PATH, { error: true, message: e.message, line: e.line });
+}
+`;
+export function register(server) {
+    server.registerTool('get_symbols', {
+        title: 'Get Symbols',
+        description: 'Get symbol definitions and instances',
+        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-symbols.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-symbols.js","sourceRoot":"","sources":["../../../src/tools/read/get-symbols.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,aAAa,EACb;QACE,KAAK,EAAE,aAAa;QACpB,WAAW,EAAE,sCAAsC;QACnD,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-text-frame-detail.d.ts

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

package/dist/tools/read/get-text-frame-detail.d.ts.map

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