android-mcp-toolkit 1.1.0

package/dist/index.js

@@ -0,0 +1,1489 @@
+#!/usr/bin/env node
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// vendor/svg2vectordrawable/svg-to-vectordrawable.js
+var require_svg_to_vectordrawable = __commonJS({
+  "vendor/svg2vectordrawable/svg-to-vectordrawable.js"(exports2, module2) {
+    var { parseSvg } = require("svgo/lib/parser");
+    var JSAPI = require("svgo/lib/svgo/jsAPI");
+    var pathBounds = require("svg-path-bounds");
+    var svgpath = require("svgpath");
+    var JS2XML = function() {
+      this.width = 24;
+      this.height = 24;
+      this.viewportWidth = 24;
+      this.viewportHeight = 24;
+      this.indent = 4;
+      this.indentLevel = 0;
+      this.vectordrawableTags = [
+        // Android vs SVG
+        "vector",
+        // svg
+        "group",
+        // g
+        "path",
+        // path, rect, circle, polygon, ellipse, polyline, line
+        "clip-path",
+        // mask
+        "aapt:attr",
+        "gradient",
+        // linearGradient, radialGradient
+        "item"
+        // stop
+      ];
+      this.vectordrawableAttrs = [
+        // Android vs SVG
+        "android:name",
+        // id
+        // <Vector>
+        "xmlns:aapt",
+        "android:width",
+        // width
+        "android:height",
+        // height
+        "android:viewportWidth",
+        "android:viewportHeight",
+        // viewBox
+        "android:tint",
+        "android:tintMode",
+        "android:autoMirrored",
+        "android:alpha",
+        // <group>
+        "android:rotation",
+        // transform="rotate(<a> [<x> <y>])"
+        "android:pivotX",
+        "android:pivotY",
+        "android:scaleX",
+        // transform="scale(<x> [<y>])"
+        "android:scaleY",
+        "android:translateX",
+        // transform="translate(<x> [<y>])"
+        "android:translateY",
+        // <path>
+        "android:pathData",
+        // d
+        "android:fillColor",
+        // fill
+        "android:fillAlpha",
+        // fill-opacity 0..1
+        "android:strokeColor",
+        // stroke
+        "android:strokeWidth",
+        // stroke-width
+        "android:strokeAlpha",
+        // stroke-opacity
+        "android:trimPathStart",
+        "android:trimPathEnd",
+        "android:trimPathOffset",
+        "android:strokeLineCap",
+        // stroke-linecap butt, round, square. Default is butt.
+        "android:strokeLineJoin",
+        // stroke-linejoin miter, round, bevel. Default is miter.
+        "android:strokeMiterLimit",
+        // stroke-miterlimit Default is 4.
+        "android:fillType",
+        // fill-rule For SDK 24+, evenOdd, nonZero. Default is nonZero.
+        // aapt
+        "name",
+        "xmlns:aapt",
+        // gradient
+        "android:type",
+        // linear, radial, sweep
+        "android:startX",
+        // x1
+        "android:startY",
+        // y1
+        "android:endX",
+        // x2
+        "android:endY",
+        // y2
+        "android:centerX",
+        // cx
+        "android:centerY",
+        // cy
+        "android:gradientRadius",
+        // r
+        "android:startColor",
+        // not support
+        "android:centerColor",
+        // not support
+        "android:endColor",
+        // not support
+        "android:tileMode",
+        // not support, disabled, clamp, repeat, mirror
+        // gradient stop
+        "android:color",
+        // stop-color
+        "android:offset"
+        // offset
+      ];
+    };
+    JS2XML.prototype.refactorData = function(data, floatPrecision, fillBlack, tint) {
+      let elemUses = data.querySelectorAll("use");
+      if (elemUses) {
+        elemUses.forEach((elem) => {
+          if (elem.hasAttr("xlink:href") || elem.hasAttr("href")) {
+            let attr = "";
+            if (elem.hasAttr("xlink:href")) {
+              attr = "xlink:href";
+            }
+            if (elem.hasAttr("href")) {
+              attr = "href";
+            }
+            let originalElem = data.querySelector(elem.attr(attr).value);
+            let newElem = new JSAPI({
+              type: originalElem.type,
+              name: originalElem.name
+            });
+            originalElem.eachAttr((attr2) => {
+              if (attr2.name !== attr2 && attr2.name !== "id") {
+                newElem.addAttr(attr2);
+              }
+            });
+            elem.eachAttr((attr2) => {
+              if (attr2.name !== attr2 && attr2.name !== "id" && attr2.name !== "class") {
+                newElem.addAttr(attr2);
+              }
+            });
+            if ((newElem.attr("x") || newElem.attr("y")) && newElem.attr("d")) {
+              let x = newElem.attr("x") ? parseFloat(newElem.attr("x").value) : 0;
+              let y = newElem.attr("y") ? parseFloat(newElem.attr("y").value) : 0;
+              let pathData = newElem.attr("d").value;
+              if (x !== 0 || y !== 0) {
+                pathData = svgpath(pathData).translate(x, y).rel().round(floatPrecision).toString();
+              }
+              newElem.removeAttr("d");
+              newElem.addAttr({ name: "d", value: pathData, prefix: "", local: "d" });
+            }
+            elem.parentNode.spliceContent(elem.parentNode.children.indexOf(elem), 0, newElem);
+            elem.parentNode.spliceContent(elem.parentNode.children.indexOf(elem), 1, []);
+          }
+        });
+      }
+      let elemHaveIds = data.querySelectorAll("path, g, circle, ellipse, line, polygon, polyline, rect");
+      if (elemHaveIds) {
+        elemHaveIds.forEach((elem) => {
+          elem.removeAttr("id");
+        });
+      }
+      let elemRects = data.querySelectorAll("rect");
+      if (elemRects) {
+        elemRects.forEach((elem) => {
+          elem.renameElem("path");
+          let x = elem.hasAttr("x") ? parseFloat(elem.attr("x").value) : 0;
+          let y = elem.hasAttr("y") ? parseFloat(elem.attr("y").value) : 0;
+          let width = elem.hasAttr("width") ? parseFloat(elem.attr("width").value) : 0;
+          let height = elem.hasAttr("height") ? parseFloat(elem.attr("height").value) : 0;
+          let rx = 0;
+          let ry = 0;
+          if (elem.hasAttr("rx") && elem.hasAttr("ry")) {
+            rx = parseFloat(elem.attr("rx").value);
+            ry = parseFloat(elem.attr("ry").value);
+          } else if (elem.hasAttr("rx")) {
+            rx = parseFloat(elem.attr("rx").value);
+            ry = rx;
+          } else if (elem.hasAttr("ry")) {
+            ry = parseFloat(elem.attr("ry").value);
+            rx = ry;
+          }
+          x = this.round(x, floatPrecision);
+          y = this.round(y, floatPrecision);
+          width = this.round(width, floatPrecision);
+          height = this.round(height, floatPrecision);
+          rx = this.round(rx, floatPrecision);
+          ry = this.round(ry, floatPrecision);
+          let pathData = this.rectToPathData(x, y, width, height, rx, ry);
+          if (rx !== 0 || ry !== 0) {
+            pathData = svgpath(pathData).unarc().rel().round(floatPrecision).toString();
+          }
+          if (elem.hasAttr("transform")) {
+            let svgTransform = elem.attr("transform").value;
+            let number = "((?:-)?\\d+(?:\\.\\d+)?)";
+            let separator = "(?:(?:\\s+)|(?:\\s*,\\s*))";
+            let translateRegExp = new RegExp(`translate\\(${number}${separator}?${number}?\\)`);
+            let scaleRegExp = new RegExp(`scale\\(${number}${separator}?${number}?\\)`);
+            let rotateRegExp = new RegExp(`rotate\\(${number}${separator}?${number}?${separator}?${number}?\\)`);
+            let translateMatch = translateRegExp.exec(svgTransform);
+            let scaleMatch = scaleRegExp.exec(svgTransform);
+            let rotateMatch = rotateRegExp.exec(svgTransform);
+            if (rotateMatch) {
+              let angle = parseFloat(rotateMatch[1]);
+              let rx2 = parseFloat(rotateMatch[2]) || 0;
+              let ry2 = parseFloat(rotateMatch[3]) || 0;
+              pathData = svgpath(pathData).rotate(angle, rx2, ry2).rel().round(floatPrecision).toString();
+            }
+            if (scaleMatch) {
+              let sx = parseFloat(scaleMatch[1]);
+              let sy = parseFloat(scaleMatch[2]) || sx;
+              pathData = svgpath(pathData).scale(sx, sy).rel().round(floatPrecision).toString();
+            }
+            if (translateMatch) {
+              let x2 = parseFloat(translateMatch[1]);
+              let y2 = parseFloat(translateMatch[2]) || 0;
+              pathData = svgpath(pathData).translate(x2, y2).rel().round(floatPrecision).toString();
+            }
+          }
+          elem.addAttr({ name: "d", value: pathData, prefix: "", local: "d" });
+          elem.removeAttr("x");
+          elem.removeAttr("y");
+          elem.removeAttr("width");
+          elem.removeAttr("height");
+          elem.removeAttr("rx");
+          elem.removeAttr("ry");
+        });
+      }
+      let elemGroups = data.querySelectorAll("g");
+      if (elemGroups) {
+        elemGroups.forEach((elem) => {
+          let childPaths = elem.querySelectorAll("path");
+          if (childPaths) {
+            childPaths.forEach((item) => {
+              if (elem.hasAttr("fill") && !elem.hasAttr("fill", "none") && !item.hasAttr("fill") && !item.hasAttr("fill", "none")) {
+                item.addAttr({ name: "fill", value: elem.attr("fill").value, prefix: "", local: "fill" });
+              }
+              if (elem.hasAttr("fill-opacity") && !item.hasAttr("fill-opacity")) {
+                item.addAttr({ name: "fill-opacity", value: elem.attr("fill-opacity").value, prefix: "", local: "fill-opacity" });
+              }
+              if (elem.hasAttr("stroke") && !item.hasAttr("stroke")) {
+                item.addAttr({ name: "stroke", value: elem.attr("stroke").value, prefix: "", local: "stroke" });
+              }
+              if (elem.hasAttr("stroke-width") && !item.hasAttr("stroke-width")) {
+                item.addAttr({ name: "stroke-width", value: elem.attr("stroke-width").value, prefix: "", local: "stroke-width" });
+              }
+              if (elem.hasAttr("stroke-opacity") && !item.hasAttr("stroke-opacity")) {
+                item.addAttr({ name: "stroke-opacity", value: elem.attr("stroke-opacity").value, prefix: "", local: "stroke-opacity" });
+              }
+              if (elem.hasAttr("stroke-linecap") && !item.hasAttr("stroke-linecap")) {
+                item.addAttr({ name: "stroke-linecap", value: elem.attr("stroke-linecap").value, prefix: "", local: "stroke-linecap" });
+              }
+              if (elem.hasAttr("stroke-linejoin") && !item.hasAttr("stroke-linejoin")) {
+                item.addAttr({ name: "stroke-linejoin", value: elem.attr("stroke-linejoin").value, prefix: "", local: "stroke-linejoin" });
+              }
+              if (elem.hasAttr("opacity")) {
+                let opacity = elem.attr("opacity").value;
+                if (item.hasAttr("opacity")) {
+                  opacity = this.round(elem.attr("opacity").value * item.attr("opacity").value, floatPrecision);
+                }
+                item.addAttr({ name: "opacity", value: opacity, prefix: "", local: "opacity" });
+              }
+              if (elem.hasAttr("fill-rule", "evenodd")) {
+                if (!item.hasAttr("fill-rule", "nonzero") && item.hasAttr("fill")) {
+                  item.addAttr({ name: "android:fillType", value: "evenOdd", prefix: "android", local: "fillType" });
+                }
+              }
+            });
+            elem.removeAttr("fill");
+            elem.removeAttr("fill-opacity");
+            elem.removeAttr("stroke");
+            elem.removeAttr("stroke-width");
+            elem.removeAttr("stroke-opacity");
+            elem.removeAttr("stroke-linecap");
+            elem.removeAttr("stroke-linejoin");
+            elem.removeAttr("opacity");
+            elem.removeAttr("fill-rule");
+          }
+          if (elem.hasAttr("transform")) {
+            let svgTransform = elem.attr("transform").value;
+            let number = "((?:-)?\\d+(?:\\.\\d+)?)";
+            let separator = "(?:(?:\\s+)|(?:\\s*,\\s*))";
+            let attrs = { rotation: "", pivotX: "", pivotY: "", scaleX: "", scaleY: "", translateX: "", translateY: "" };
+            let translateRegExp = new RegExp(`translate\\(${number}${separator}?${number}?\\)`, "g");
+            let translateX = 0;
+            let translateY = 0;
+            let translateMatch;
+            while (translateMatch = translateRegExp.exec(svgTransform)) {
+              translateX += Number(translateMatch[1]);
+              translateY += Number(translateMatch[2]);
+            }
+            if (translateX !== 0 && !isNaN(translateX)) {
+              attrs.translateX = translateX;
+            }
+            if (translateY !== 0 && !isNaN(translateY)) {
+              attrs.translateY = translateY;
+            }
+            let scaleRegExp = new RegExp(`scale\\(${number}${separator}?${number}?\\)`, "g");
+            let scaleX = 1;
+            let scaleY = 1;
+            let scaleMatch;
+            while (scaleMatch = scaleRegExp.exec(svgTransform)) {
+              scaleX *= Number(scaleMatch[1]);
+              scaleY *= Number(scaleMatch[2]) || Number(scaleMatch[1]);
+            }
+            if (scaleX !== 1 && !isNaN(scaleX)) {
+              attrs.scaleX = scaleX;
+            }
+            if (scaleY !== 1 && !isNaN(scaleY)) {
+              attrs.scaleY = scaleY;
+            }
+            let rotateRegExp = new RegExp(`rotate\\(${number}${separator}?${number}?${separator}?${number}?\\)`);
+            let rotateMatch = rotateRegExp.exec(svgTransform);
+            if (rotateMatch) {
+              attrs.rotation = rotateMatch[1];
+              attrs.pivotX = rotateMatch[2] || "";
+              attrs.pivotY = rotateMatch[3] || "";
+            }
+            let skewRegExp = new RegExp(`skew([XY])\\(${number}\\)`);
+            let matrixRegExp = new RegExp("matrix\\((.*)\\)");
+            let skewMatch = skewRegExp.exec(svgTransform);
+            let matrixMatch = matrixRegExp.exec(svgTransform);
+            if (skewMatch || matrixMatch) {
+              let paths = elem.querySelectorAll("path");
+              if (paths) {
+                paths.forEach((path) => {
+                  let pathData = path.attr("d").value;
+                  if (skewMatch) {
+                    let skewX = skewMatch[1] === "X" ? parseFloat(skewMatch[2]) : 0;
+                    let skewY = skewMatch[1] === "Y" ? parseFloat(skewMatch[2]) : 0;
+                    pathData = svgpath(pathData).skewX(skewX).skewY(skewY).rel().round(floatPrecision).toString();
+                  }
+                  if (matrixMatch) {
+                    let matrix = matrixMatch[1].split(" ").map((item) => parseFloat(item));
+                    pathData = svgpath(pathData).matrix(matrix).rel().round(floatPrecision).toString();
+                  }
+                  path.removeAttr("d");
+                  path.addAttr({ name: "d", value: pathData, prefix: "", local: "d" });
+                });
+              }
+            }
+            Object.keys(attrs).forEach((key) => {
+              if (attrs[key] !== "" && (attrs[key] !== "0" && (key !== "scaleX" || key !== "scaleY"))) {
+                elem.addAttr({ name: `android:${key}`, value: this.round(attrs[key], floatPrecision), prefix: "android", local: key });
+              }
+            });
+            elem.removeAttr("transform");
+          }
+        });
+      }
+      elemGroups = data.querySelectorAll("g");
+      if (elemGroups) {
+        elemGroups.forEach((elem) => {
+          if (Object.keys(elem.attrs).length === 0) {
+            elem.parentNode.spliceContent(elem.parentNode.children.indexOf(elem), 0, elem.children);
+            elem.parentNode.spliceContent(elem.parentNode.children.indexOf(elem), 1, []);
+          } else {
+            elem.renameElem("group");
+          }
+        });
+      }
+      let elemSVG = data.querySelector("svg");
+      if (elemSVG) {
+        elemSVG.renameElem("vector");
+        if (elemSVG.hasAttr("width") && elemSVG.hasAttr("height")) {
+          this.width = parseInt(elemSVG.attr("width").value);
+          this.height = parseInt(elemSVG.attr("height").value);
+        }
+        if (elemSVG.hasAttr("viewBox")) {
+          let [x, y, w, h] = elemSVG.attr("viewBox").value.split(/\s+/);
+          this.viewportWidth = w;
+          this.viewportHeight = h;
+          if (!elemSVG.hasAttr("width") && !elemSVG.hasAttr("height")) {
+            this.width = w;
+            this.height = h;
+          }
+        }
+        elemSVG.attrs = {};
+        if (data.querySelector("linearGradient, radialGradient, sweepGradient, aapt\\:attr")) {
+          elemSVG.addAttr({ name: "xmlns:aapt", value: "http://schemas.android.com/aapt", prefix: "xmlns", local: "aapt" });
+        }
+        elemSVG.addAttr({ name: "android:width", value: this.width + "dp", prefix: "android", local: "width" });
+        elemSVG.addAttr({ name: "android:height", value: this.height + "dp", prefix: "android", local: "height" });
+        elemSVG.addAttr({ name: "android:viewportWidth", value: this.viewportWidth, prefix: "android", local: "viewportWidth" });
+        elemSVG.addAttr({ name: "android:viewportHeight", value: this.viewportHeight, prefix: "android", local: "viewportHeight" });
+        if (tint) {
+          if (/^#[A-F0-9]{1,8}$/i.test(tint)) {
+            tint = tint.toUpperCase();
+          }
+          elemSVG.addAttr({ name: "android:tint", value: tint, prefix: "android", local: "tint" });
+        }
+      }
+      let elemGradients = data.querySelectorAll("linearGradient, radialGradient, sweepGradient");
+      if (elemGradients) {
+        elemGradients.forEach((gradient) => {
+          if (gradient.hasAttr("id")) {
+            let gradientId = gradient.attr("id").value;
+            let gradientPaths = data.querySelectorAll(`path[fill="url(#${gradientId})"], path[stroke="url(#${gradientId})"]`);
+            if (gradientPaths) {
+              gradientPaths.forEach((path) => {
+                this.addGradientToElement(gradient, path, floatPrecision);
+              });
+            }
+          }
+          gradient.parentNode.spliceContent(gradient.parentNode.children.indexOf(gradient), 1, []);
+        });
+      }
+      let elemMasks = data.querySelectorAll("mask");
+      if (elemMasks) {
+        elemMasks.forEach((elem) => {
+          if (elem.hasAttr("id")) {
+            let maskId = elem.attr("id").value;
+            let clipMaskElem = elem.children[0];
+            let pathData = svgpath(clipMaskElem.attr("d").value).round(floatPrecision).toString();
+            let maskGroup = new JSAPI({
+              type: "element",
+              name: "group",
+              attrs: {},
+              children: []
+            });
+            clipMaskElem.renameElem("clip-path");
+            clipMaskElem.attrs = {};
+            clipMaskElem.addAttr({ name: "android:pathData", value: pathData, prefix: "android", local: "pathData" });
+            maskGroup.children.push(clipMaskElem);
+            let maskedElems = data.querySelectorAll(`*[mask="url(#${maskId})"]`);
+            if (maskedElems) {
+              maskedElems.forEach((item) => {
+                item.removeAttr("mask");
+                maskGroup.children.push(item);
+              });
+              elem.parentNode.spliceContent(elem.parentNode.children.indexOf(maskedElems[0]), maskedElems.length, maskGroup);
+            } else {
+              elem.parentNode.spliceContent(elem.parentNode.children.indexOf(elem), 0, maskGroup);
+            }
+          }
+          elem.parentNode.spliceContent(elem.parentNode.children.indexOf(elem), 1, []);
+        });
+      }
+      let elemPaths = data.querySelectorAll("path");
+      if (elemPaths) {
+        elemPaths.forEach((elem) => {
+          if (elem.hasAttr("fill")) {
+            if (elem.attr("fill").value === "none") {
+              elem.removeAttr("fill");
+            } else if (!/^url\(#.*\)$/.test(elem.attr("fill").value)) {
+              let color = this.svgHexToAndroid(elem.attr("fill").value);
+              let fillAttr = { name: "android:fillColor", value: color, prefix: "android", local: "fillColor" };
+              if (elem.hasAttr("fill-opacity")) {
+                fillAttr.value = this.mergeColorAndOpacity(fillAttr.value, elem.attr("fill-opacity").value);
+                elem.removeAttr("fill-opacity");
+              }
+              elem.addAttr(fillAttr);
+              elem.removeAttr("fill");
+            }
+          } else if (fillBlack) {
+            let fillAttr = { name: "android:fillColor", value: "#FF000000", prefix: "android", local: "fillColor" };
+            elem.addAttr(fillAttr);
+          }
+          if (elem.hasAttr("opacity")) {
+            elem.addAttr({ name: "android:fillAlpha", value: elem.attr("opacity").value, prefix: "android", local: "fillAlpha" });
+          }
+          if (elem.hasAttr("stroke")) {
+            if (!/^url\(#.*\)$/.test(elem.attr("stroke").value) && elem.attr("stroke").value !== "none") {
+              let color = this.svgHexToAndroid(elem.attr("stroke").value);
+              let strokeAttr = { name: "android:strokeColor", value: color, prefix: "android", local: "strokeColor" };
+              if (elem.hasAttr("stroke-opacity")) {
+                strokeAttr.value = this.mergeColorAndOpacity(strokeAttr.value, elem.attr("stroke-opacity").value);
+                elem.removeAttr("stroke-opacity");
+              }
+              elem.addAttr(strokeAttr);
+              elem.removeAttr("stroke");
+            }
+            if (elem.hasAttr("opacity")) {
+              elem.addAttr({ name: "android:strokeAlpha", value: elem.attr("opacity").value, prefix: "android", local: "strokeAlpha" });
+            }
+            let strokeWidthAttr = { name: "android:strokeWidth", value: 0, prefix: "android", local: "strokeWidth" };
+            if (!elem.hasAttr("stroke-width")) {
+              strokeWidthAttr.value = 1;
+            } else {
+              strokeWidthAttr.value = elem.attr("stroke-width").value;
+              elem.removeAttr("stroke-width");
+            }
+            elem.addAttr(strokeWidthAttr);
+            let strokeExtraAttrs = ["stroke-linecap", "stroke-linejoin", "stroke-miterlimit"];
+            let strokeExtraAttrsAndroid = ["strokeLineCap", "strokeLineJoin", "strokeMiterLimit"];
+            strokeExtraAttrs.forEach((attr, index) => {
+              if (elem.hasAttr(attr)) {
+                let localName = strokeExtraAttrsAndroid[index];
+                elem.addAttr({ name: "android:" + localName, value: elem.attr(attr).value, prefix: "android", local: localName });
+                elem.removeAttr("attr");
+              }
+            });
+          }
+          if (elem.hasAttr("opacity")) {
+            elem.removeAttr("opacity");
+          }
+          elem.removeAttr("fill-rule", "nonzero");
+          if (elem.hasAttr("fill-rule", "evenodd")) {
+            elem.addAttr({ name: "android:fillType", value: "evenOdd", prefix: "android", local: "fillType" });
+            elem.removeAttr("fill-rule", "evenodd");
+          }
+          if (elem.hasAttr("d")) {
+            let pathData = svgpath(elem.attr("d").value).round(floatPrecision).toString();
+            elem.addAttr({ name: "android:pathData", value: pathData, prefix: "android", local: "pathData" });
+            elem.removeAttr("d");
+          }
+        });
+      }
+    };
+    JS2XML.prototype.addGradientToElement = function(gradient, elem, floatPrecision) {
+      let vectorDrawableGradient = new JSAPI({
+        type: "element",
+        name: "gradient",
+        children: []
+      });
+      let vectorDrawableAapt = new JSAPI({
+        type: "element",
+        name: "aapt:attr",
+        children: [vectorDrawableGradient]
+      });
+      let gradientId = gradient.attr("id").value;
+      if (elem.hasAttr("fill", `url(#${gradientId})`)) {
+        vectorDrawableAapt.addAttr({ name: "name", value: "android:fillColor", prefix: "", local: "name" });
+        elem.removeAttr("fill");
+      }
+      if (elem.hasAttr("stroke", `url(#${gradientId})`)) {
+        vectorDrawableAapt.addAttr({ name: "name", value: "android:strokeColor", prefix: "", local: "name" });
+        elem.removeAttr("stroke");
+      }
+      this.adjustGradientCoordinate(gradient, elem, floatPrecision);
+      if (gradient.name === "linearGradient") {
+        vectorDrawableGradient.addAttr({ name: "android:type", value: "linear", prefix: "android", local: "type" });
+        let startX = gradient.hasAttr("x1") ? gradient.attr("x1").value : "0";
+        let startY = gradient.hasAttr("y1") ? gradient.attr("y1").value : "0";
+        let endX = gradient.hasAttr("x2") ? gradient.attr("x2").value : this.viewportWidth;
+        let endY = gradient.hasAttr("y2") ? gradient.attr("y2").value : "0";
+        vectorDrawableGradient.addAttr({ name: "android:startX", value: startX, prefix: "android", local: "startX" });
+        vectorDrawableGradient.addAttr({ name: "android:startY", value: startY, prefix: "android", local: "startY" });
+        vectorDrawableGradient.addAttr({ name: "android:endX", value: endX, prefix: "android", local: "endX" });
+        vectorDrawableGradient.addAttr({ name: "android:endY", value: endY, prefix: "android", local: "endY" });
+      }
+      if (gradient.name === "radialGradient") {
+        vectorDrawableGradient.addAttr({ name: "android:type", value: "radial", prefix: "android", local: "type" });
+        let centerX = gradient.hasAttr("cx") ? gradient.attr("cx").value : this.viewportWidth / 2;
+        let centerY = gradient.hasAttr("cy") ? gradient.attr("cy").value : this.viewportHeight / 2;
+        if (gradient.hasAttr("rx")) centerX = gradient.attr("rx").value;
+        if (gradient.hasAttr("ry")) centerY = gradient.attr("ry").value;
+        let gradientRadius = gradient.hasAttr("r") ? gradient.attr("r").value : Math.max(this.viewportWidth, this.viewportHeight) / 2;
+        vectorDrawableGradient.addAttr({ name: "android:centerX", value: centerX, prefix: "android", local: "centerX" });
+        vectorDrawableGradient.addAttr({ name: "android:centerY", value: centerY, prefix: "android", local: "centerY" });
+        vectorDrawableGradient.addAttr({ name: "android:gradientRadius", value: gradientRadius, prefix: "android", local: "gradientRadius" });
+      }
+      if (gradient.name === "sweepGradient") {
+        vectorDrawableGradient.addAttr({ name: "android:type", value: "sweep", prefix: "android", local: "type" });
+        let centerX = gradient.hasAttr("cx") ? gradient.attr("cx").value : this.viewportWidth / 2;
+        let centerY = gradient.hasAttr("cy") ? gradient.attr("cy").value : this.viewportHeight / 2;
+        vectorDrawableGradient.addAttr({ name: "android:centerX", value: centerX, prefix: "android", local: "centerX" });
+        vectorDrawableGradient.addAttr({ name: "android:centerY", value: centerY, prefix: "android", local: "centerY" });
+      }
+      gradient.children.forEach((item) => {
+        let colorStop = new JSAPI({
+          type: "element",
+          name: "item"
+        });
+        const stopColorAttr = item.attr("stop-color");
+        let color = this.svgHexToAndroid(stopColorAttr == null ? "#000000FF" : stopColorAttr.value);
+        const offsetAttr = item.attr("offset");
+        let offset = offsetAttr == null ? 0 : offsetAttr.value;
+        if (this.isPercent(offset)) {
+          offset = Math.round(parseFloat(offset)) / 100;
+        }
+        if (item.hasAttr("stop-opacity")) {
+          color = this.mergeColorAndOpacity(color, item.attr("stop-opacity").value);
+        }
+        colorStop.addAttr({ name: "android:color", value: color, prefix: "android", local: "color" });
+        colorStop.addAttr({ name: "android:offset", value: offset, prefix: "android", local: "offset" });
+        vectorDrawableGradient.children.push(colorStop);
+      });
+      if (!elem.children) elem.children = [];
+      elem.children.push(vectorDrawableAapt);
+    };
+    JS2XML.prototype.adjustGradientCoordinate = function(gradient, elem, floatPrecision) {
+      if (gradient.elem === "linearGradient") {
+        if (!gradient.hasAttr("x1")) {
+          gradient.addAttr({ name: "x1", value: "0", prefix: "", local: "x1" });
+        }
+        if (!gradient.hasAttr("y1")) {
+          gradient.addAttr({ name: "y1", value: "0", prefix: "", local: "y1" });
+        }
+        if (!gradient.hasAttr("x2")) {
+          gradient.addAttr({ name: "x2", value: "100%", prefix: "", local: "x2" });
+        }
+        if (!gradient.hasAttr("y2")) {
+          gradient.addAttr({ name: "y2", value: "100%", prefix: "", local: "y2" });
+        }
+      }
+      if (gradient.elem === "radialGradient") {
+        if (!gradient.hasAttr("cx")) {
+          gradient.addAttr({ name: "cx", value: "50%", prefix: "", local: "cx" });
+        }
+        if (!gradient.hasAttr("cy")) {
+          gradient.addAttr({ name: "cy", value: "50%", prefix: "", local: "cy" });
+        }
+        if (!gradient.hasAttr("r")) {
+          gradient.addAttr({ name: "r", value: "50%", prefix: "", local: "r" });
+        }
+      }
+      if (gradient.elem === "sweepGradient") {
+        if (!gradient.hasAttr("cx")) {
+          gradient.addAttr({ name: "cx", value: "50%", prefix: "", local: "cx" });
+        }
+        if (!gradient.hasAttr("cy")) {
+          gradient.addAttr({ name: "cy", value: "50%", prefix: "", local: "cy" });
+        }
+      }
+      gradient.eachAttr((attr) => {
+        let positionAttrs = [
+          // SVG linearGradient
+          "x1",
+          "y1",
+          "x2",
+          "y2",
+          // SVG radialGradient, Android VectorDrawable not support 'fx' and 'fy'.
+          "cx",
+          "cy",
+          "r",
+          "fx",
+          "fy"
+        ];
+        if (positionAttrs.indexOf(attr.name) >= 0) {
+          if (!gradient.hasAttr("gradientUnits", "userSpaceOnUse")) {
+            let [x1, y1, x2, y2] = pathBounds(elem.attr("d").value);
+            if (this.isPercent(attr.value)) {
+              let valueFloat = parseFloat(attr.value) / 100;
+              if (attr.name === "x1" || attr.name === "x2" || attr.name === "cx" || attr.name === "fx") {
+                attr.value = x1 + (x2 - x1) * valueFloat;
+              }
+              if (attr.name === "y1" || attr.name === "y2" || attr.name === "cy" || attr.name === "fy") {
+                attr.value = y1 + (y2 - y1) * valueFloat;
+              }
+              if (attr.name === "r") {
+                attr.value = Math.max(x2 - x1, y2 - y1) * valueFloat;
+              }
+            } else {
+              if (attr.name === "x1" || attr.name === "x2" || attr.name === "cx" || attr.name === "fx") {
+                attr.value = x1 + attr.value;
+              }
+              if (attr.name === "y1" || attr.name === "y2" || attr.name === "cy" || attr.name === "fy") {
+                attr.value = y1 + attr.value;
+              }
+            }
+          } else {
+            if (this.isPercent(attr.value)) {
+              let valueFloat = parseFloat(attr.value) / 100;
+              if (attr.name === "x1" || attr.name === "x2" || attr.name === "cx" || attr.name === "fx") {
+                attr.value = this.viewportWidth * valueFloat;
+              }
+              if (attr.name === "y1" || attr.name === "y2" || attr.name === "cy" || attr.name === "fy") {
+                attr.value = this.viewportHeight * valueFloat;
+              }
+              if (attr.name === "r") {
+                attr.value = Math.max(this.viewportWidth, this.viewportHeight) * valueFloat;
+              }
+            }
+          }
+          attr.value = this.round(attr.value, floatPrecision);
+        }
+      }, this);
+    };
+    JS2XML.prototype.mergeColorAndOpacity = function(androidColorHex, opacity) {
+      let opacityFromAndroidColor = parseInt(androidColorHex.substr(1, 2), 16) / 255;
+      let opacityHex = Number(Math.round(opacity * opacityFromAndroidColor * 255)).toString(16).toUpperCase();
+      if (opacityHex.length === 1) {
+        opacityHex = "0" + opacityHex;
+      }
+      return "#" + opacityHex + androidColorHex.substr(-6);
+    };
+    JS2XML.prototype.isPercent = function(value) {
+      return /(-)?\d+(\.d+)?%$/.test(String(value));
+    };
+    JS2XML.prototype.round = function(value, floatPrecision) {
+      return Math.round(value * Math.pow(10, floatPrecision)) / Math.pow(10, floatPrecision);
+    };
+    JS2XML.prototype.convert = function(data, floatPrecision, strict, fillBlack, tint) {
+      this.refactorData(data, floatPrecision, fillBlack, tint);
+      return this.travelConvert(data, strict);
+    };
+    JS2XML.prototype.travelConvert = function(data, strict) {
+      let xml = "";
+      this.indentLevel++;
+      if (data.children) {
+        data.children.forEach((item) => {
+          if (this.vectordrawableTags.indexOf(item.name) >= 0) {
+            xml += this.createElement(item, strict);
+          } else if (strict) {
+            throw new Error("Unsupported element " + item.name);
+          }
+        }, this);
+      }
+      this.indentLevel--;
+      return xml;
+    };
+    JS2XML.prototype.createElement = function(data, strict) {
+      if (data.isEmpty()) {
+        return this.createIndent() + "<" + data.name + this.createAttrs(data, strict) + "/>\n";
+      } else {
+        let processedData = "";
+        processedData += this.travelConvert(data, strict);
+        return this.createIndent() + "<" + data.name + this.createAttrs(data, strict) + ">\n" + processedData + this.createIndent() + "</" + data.name + ">\n";
+      }
+    };
+    JS2XML.prototype.createAttrs = function(elem, strict) {
+      let attrs = "";
+      if (elem.name === "vector") {
+        attrs += ' xmlns:android="http://schemas.android.com/apk/res/android"';
+      }
+      elem.eachAttr(function(attr) {
+        if (attr.value !== void 0) {
+          if (this.vectordrawableAttrs.indexOf(attr.name) >= 0) {
+            if (["fillColor", "strokeColor", "color"].indexOf(attr.local) >= 0) {
+              attr.value = this.simplifyAndroidHexCode(attr.value);
+            }
+            if (elem.name === "aapt:attr" && attr.name === "name") {
+              attrs += " " + attr.name + '="' + attr.value + '"';
+            } else {
+              attrs += "\n" + this.createIndent() + " ".repeat(this.indent) + attr.name + '="' + attr.value + '"';
+            }
+          } else if (strict) {
+            throw new Error("Unsupported attribute " + attr.name);
+          }
+        }
+      }, this);
+      return attrs;
+    };
+    JS2XML.prototype.svgHexToAndroid = function(hexColor) {
+      const toByte = (value) => {
+        let numeric = value;
+        if (typeof numeric === "string" && numeric.trim().endsWith("%")) {
+          numeric = Math.round(parseFloat(numeric) * 2.55);
+        }
+        numeric = Math.min(255, Math.max(0, Math.round(Number(numeric))));
+        return numeric;
+      };
+      const rgbaToHex = (r, g, b, a = 1) => {
+        const alpha = Math.min(1, Math.max(0, Number(a)));
+        const rHex = toByte(r).toString(16).padStart(2, "0");
+        const gHex = toByte(g).toString(16).padStart(2, "0");
+        const bHex = toByte(b).toString(16).padStart(2, "0");
+        const aHex = Math.round(alpha * 255).toString(16).padStart(2, "0");
+        return `#${rHex}${gHex}${bHex}${aHex}`;
+      };
+      const hslToRgb = (h, s, l) => {
+        const hue = (Number(h) % 360 + 360) % 360 / 360;
+        const sat = Math.min(1, Math.max(0, s));
+        const light = Math.min(1, Math.max(0, l));
+        if (sat === 0) {
+          const grey = Math.round(light * 255);
+          return [grey, grey, grey];
+        }
+        const q = light < 0.5 ? light * (1 + sat) : light + sat - light * sat;
+        const p = 2 * light - q;
+        const hueToChannel = (t) => {
+          let temp = t;
+          if (temp < 0) temp += 1;
+          if (temp > 1) temp -= 1;
+          if (temp < 1 / 6) return p + (q - p) * 6 * temp;
+          if (temp < 1 / 2) return q;
+          if (temp < 2 / 3) return p + (q - p) * (2 / 3 - temp) * 6;
+          return p;
+        };
+        return [
+          Math.round(hueToChannel(hue + 1 / 3) * 255),
+          Math.round(hueToChannel(hue) * 255),
+          Math.round(hueToChannel(hue - 1 / 3) * 255)
+        ];
+      };
+      const keywordColors = {
+        black: "#000000FF",
+        white: "#FFFFFFFF",
+        red: "#FF0000FF",
+        green: "#008000FF",
+        blue: "#0000FFFF",
+        yellow: "#FFFF00FF",
+        cyan: "#00FFFFFF",
+        magenta: "#FF00FFFF",
+        gray: "#808080FF",
+        grey: "#808080FF",
+        orange: "#FFA500FF",
+        purple: "#800080FF",
+        pink: "#FFC0CBFF",
+        brown: "#A52A2AFF",
+        transparent: "#00000000"
+      };
+      const normalized = hexColor.trim();
+      if (/^#[0-9a-f]{8}$/i.test(normalized)) {
+        hexColor = "#" + normalized.substr(7, 2) + normalized.substr(1, 6);
+      } else if (/^#[0-9a-f]{4}$/i.test(normalized)) {
+        hexColor = "#" + normalized[4].repeat(2) + normalized[1].repeat(2) + normalized[2].repeat(2) + normalized[3].repeat(2);
+      } else if (/^#[0-9a-f]{6}$/i.test(normalized)) {
+        hexColor = "#FF" + normalized.substr(1, 6);
+      } else if (/^#[0-9a-f]{3}$/i.test(normalized)) {
+        hexColor = "#FF" + normalized[1].repeat(2) + normalized[2].repeat(2) + normalized[3].repeat(2);
+      } else if (/^rgba?\(/i.test(normalized)) {
+        const rgba = normalized.replace(/^rgba?\(/i, "").replace(/\)$/, "").split(",");
+        if (rgba.length >= 3) {
+          const alpha = rgba.length === 4 ? rgba[3] : 1;
+          hexColor = rgbaToHex(rgba[0], rgba[1], rgba[2], alpha);
+        } else {
+          hexColor = "#FF000000";
+        }
+      } else if (/^hsla?\(/i.test(normalized)) {
+        const hsla = normalized.replace(/^hsla?\(/i, "").replace(/\)$/, "").split(",");
+        if (hsla.length >= 3) {
+          const hue = parseFloat(hsla[0]);
+          const sat = hsla[1].trim().endsWith("%") ? parseFloat(hsla[1]) / 100 : parseFloat(hsla[1]);
+          const light = hsla[2].trim().endsWith("%") ? parseFloat(hsla[2]) / 100 : parseFloat(hsla[2]);
+          const alpha = hsla.length === 4 ? hsla[3] : 1;
+          const [r, g, b] = hslToRgb(hue, sat, light);
+          hexColor = rgbaToHex(r, g, b, alpha);
+        } else {
+          hexColor = "#FF000000";
+        }
+      } else if (keywordColors[normalized.toLowerCase()]) {
+        hexColor = keywordColors[normalized.toLowerCase()];
+      } else {
+        hexColor = "#FF000000";
+      }
+      return hexColor.toUpperCase();
+    };
+    JS2XML.prototype.simplifyAndroidHexCode = function(androidColorHex) {
+      if (/#FF[A-F0-9]{6}/.test(androidColorHex)) {
+        androidColorHex = "#" + androidColorHex.substr(-6);
+      }
+      let partOdd = androidColorHex.substr(1).split("").filter((item, index) => {
+        return index % 2 === 0;
+      }).join("");
+      let partEven = androidColorHex.substr(1).split("").filter((item, index) => {
+        return index % 2 === 1;
+      }).join("");
+      if (partOdd === partEven) {
+        androidColorHex = "#" + partOdd;
+      }
+      return androidColorHex;
+    };
+    JS2XML.prototype.createIndent = function() {
+      let indent = " ".repeat(this.indent);
+      indent = indent.repeat(this.indentLevel - 1);
+      return indent;
+    };
+    JS2XML.prototype.rectToPathData = function(x, y, width, height, rx, ry) {
+      let d = "";
+      if (rx === 0 && ry === 0) {
+        d = "M" + x + "," + y + "h" + width + "v" + height + "H" + x + "z";
+      } else {
+        d = "M" + x + "," + (y + ry) + "a" + rx + " -" + ry + " 0 0 1 " + rx + " -" + ry + "h" + (width - rx * 2) + "a" + rx + " " + ry + " 0 0 1 " + rx + " " + ry + "v" + (height - ry * 2) + "a-" + rx + " " + ry + " 0 0 1 -" + rx + " " + ry + "h-" + (width - rx * 2) + "a-" + rx + " -" + ry + " 0 0 1 -" + rx + " -" + ry + "z";
+      }
+      return d;
+    };
+    module2.exports = function(svgCode, options) {
+      let floatPrecision = 2;
+      let strict = false;
+      let fillBlack = false;
+      let xmlTag = false;
+      let tint;
+      if (options) {
+        if (options.floatPrecision) {
+          floatPrecision = options.floatPrecision;
+        }
+        if (options.strict) {
+          strict = options.strict;
+        }
+        if (options.fillBlack) {
+          fillBlack = options.fillBlack;
+        }
+        if (options.xmlTag) {
+          xmlTag = options.xmlTag;
+        }
+        if (options.tint) {
+          tint = options.tint;
+        }
+      }
+      return new Promise((resolve, reject) => {
+        let data = parseSvg(svgCode);
+        if (data.error) {
+          reject(data.error);
+        } else {
+          let xml = new JS2XML().convert(data, floatPrecision, strict, fillBlack, tint);
+          if (xmlTag) {
+            xml = '<?xml version="1.0" encoding="utf-8"?>\n' + xml;
+          }
+          resolve(xml);
+        }
+      });
+    };
+  }
+});
+
+// vendor/svg2vectordrawable/svgo-config.js
+var require_svgo_config = __commonJS({
+  "vendor/svg2vectordrawable/svgo-config.js"(exports2, module2) {
+    module2.exports = function(floatPrecision = 2) {
+      const svgoConfig = {
+        info: {
+          input: "string"
+        },
+        plugins: [
+          {
+            name: "removeDoctype"
+          },
+          {
+            name: "removeXMLProcInst"
+          },
+          {
+            name: "removeComments"
+          },
+          {
+            name: "removeMetadata"
+          },
+          {
+            name: "removeEditorsNSData"
+          },
+          {
+            name: "cleanupAttrs"
+          },
+          {
+            name: "mergeStyles"
+          },
+          {
+            name: "inlineStyles",
+            params: { onlyMatchedOnce: false }
+          },
+          {
+            name: "minifyStyles"
+          },
+          {
+            name: "cleanupIDs",
+            active: false
+          },
+          {
+            name: "removeUselessDefs"
+          },
+          {
+            name: "cleanupNumericValues",
+            params: { floatPrecision, leadingZero: false }
+          },
+          {
+            name: "convertColors",
+            params: { shorthex: false, shortname: false }
+          },
+          {
+            name: "removeUnknownsAndDefaults",
+            params: { unknownContent: false, unknownAttrs: false }
+          },
+          {
+            name: "removeNonInheritableGroupAttrs"
+          },
+          {
+            name: "removeUselessStrokeAndFill"
+          },
+          {
+            name: "removeViewBox",
+            active: false
+          },
+          {
+            name: "cleanupEnableBackground"
+          },
+          {
+            name: "removeHiddenElems"
+          },
+          {
+            name: "removeEmptyText"
+          },
+          {
+            name: "convertShapeToPath",
+            params: { convertArcs: true, floatPrecision }
+          },
+          {
+            name: "convertEllipseToCircle"
+          },
+          {
+            name: "moveElemsAttrsToGroup",
+            active: false
+          },
+          {
+            name: "moveGroupAttrsToElems"
+          },
+          {
+            name: "collapseGroups"
+          },
+          {
+            name: "convertPathData",
+            params: { floatPrecision, transformPrecision: floatPrecision, leadingZero: false, makeArcs: false, noSpaceAfterFlags: false, collapseRepeated: false }
+          },
+          {
+            name: "convertTransform"
+          },
+          {
+            name: "removeEmptyAttrs"
+          },
+          {
+            name: "removeEmptyContainers"
+          },
+          {
+            name: "mergePaths",
+            active: false
+          },
+          {
+            name: "removeUnusedNS"
+          },
+          {
+            name: "sortDefsChildren"
+          },
+          {
+            name: "removeTitle"
+          },
+          {
+            name: "removeDesc"
+          },
+          {
+            name: "removeXMLNS",
+            active: false
+          },
+          {
+            name: "removeRasterImages"
+          },
+          {
+            name: "cleanupListOfValues",
+            params: { floatPrecision, leadingZero: false }
+          },
+          {
+            name: "sortAttrs",
+            active: false
+          },
+          {
+            name: "convertStyleToAttrs",
+            active: false
+          },
+          {
+            name: "prefixIds",
+            active: false
+          },
+          {
+            name: "removeDimensions",
+            active: false
+          },
+          {
+            name: "removeAttrs",
+            active: false
+          },
+          {
+            name: "removeAttributesBySelector",
+            active: false
+          },
+          {
+            name: "removeElementsByAttr",
+            active: false
+          },
+          {
+            name: "addClassesToSVGElement",
+            active: false
+          },
+          {
+            name: "removeStyleElement",
+            active: false
+          },
+          {
+            name: "removeScriptElement",
+            active: false
+          },
+          {
+            name: "addAttributesToSVGElement",
+            active: false
+          },
+          {
+            name: "removeOffCanvasPaths",
+            active: false
+          },
+          {
+            name: "reusePaths",
+            active: false
+          }
+        ]
+      };
+      return svgoConfig;
+    };
+  }
+});
+
+// vendor/svg2vectordrawable/main.node.js
+var require_main_node = __commonJS({
+  "vendor/svg2vectordrawable/main.node.js"(exports2, module2) {
+    var { optimize } = require("svgo");
+    var svg2vectordrawable = require_svg_to_vectordrawable();
+    var svgoConfig = require_svgo_config();
+    module2.exports = function(svgCode, options) {
+      let floatPrecision = options ? options.floatPrecision : 2;
+      const result = optimize(svgCode, svgoConfig(floatPrecision));
+      svgCode = result.data;
+      return svg2vectordrawable(svgCode, options);
+    };
+  }
+});
+
+// vendor/svg2vectordrawable/index.js
+var require_svg2vectordrawable = __commonJS({
+  "vendor/svg2vectordrawable/index.js"(exports2, module2) {
+    module2.exports = require_main_node();
+  }
+});
+
+// src/tools/svgTool.js
+var require_svgTool = __commonJS({
+  "src/tools/svgTool.js"(exports2, module2) {
+    var fs = require("fs/promises");
+    var path = require("path");
+    var { createHash } = require("crypto");
+    var z = require("zod/v4");
+    var svg2vectordrawable = require_svg2vectordrawable();
+    var svgToolInstructions2 = [
+      "Use this server to convert SVG into Android VectorDrawable XML (fast, cached).",
+      "Call tool convert-svg-to-android-drawable for any SVG\u2192VectorDrawable conversion or option tuning.",
+      "Prefer inline SVG via svg; if using svgPath, pass absolute or caller-provided paths only\u2014do not invent paths.",
+      "Set outputPath only if a file should be written; otherwise XML is returned inline.",
+      "Defaults: floatPrecision=2, fillBlack=false, xmlTag=false, cache=true.",
+      "Use fillBlack=true only when the SVG lacks fill and black is desired; set tint only if the caller explicitly requests a tint color.",
+      "Do not alter caller SVG content beyond conversion; keep inputs as provided."
+    ].join("\n");
+    var convertInputSchema = z.object({
+      svg: z.string().min(1).describe("Inline SVG markup to convert").optional(),
+      svgPath: z.string().min(1).describe("Path to an SVG file to read").optional(),
+      outputPath: z.string().min(1).describe("Optional output path for generated VectorDrawable XML").optional(),
+      floatPrecision: z.number().int().min(0).max(6).default(2).describe("Decimal precision when serializing coordinates"),
+      fillBlack: z.boolean().default(false).describe("Force fill color black when missing"),
+      xmlTag: z.boolean().default(false).describe("Include XML declaration"),
+      tint: z.string().min(1).optional().describe("Android tint color (e.g. #FF000000)"),
+      cache: z.boolean().default(true).describe("Reuse cached result for identical inputs within this process")
+    }).refine((data) => data.svg || data.svgPath, { message: "Provide either svg or svgPath" });
+    var conversionCache = /* @__PURE__ */ new Map();
+    var MAX_CACHE_SIZE = 32;
+    function makeCacheKey(svg, options) {
+      const hash = createHash("sha256");
+      hash.update(svg);
+      hash.update(JSON.stringify(options));
+      return hash.digest("hex");
+    }
+    function getCached(key) {
+      const existing = conversionCache.get(key);
+      if (!existing) return null;
+      conversionCache.delete(key);
+      conversionCache.set(key, existing);
+      return existing;
+    }
+    function setCache(key, value) {
+      if (conversionCache.size >= MAX_CACHE_SIZE) {
+        const oldestKey = conversionCache.keys().next().value;
+        if (oldestKey) {
+          conversionCache.delete(oldestKey);
+        }
+      }
+      conversionCache.set(key, value);
+    }
+    async function loadSvg(params) {
+      if (params.svg) return params.svg;
+      const resolvedPath = path.resolve(params.svgPath);
+      return fs.readFile(resolvedPath, "utf8");
+    }
+    async function maybeWriteOutput(outputPath, xml) {
+      if (!outputPath) return null;
+      const resolvedPath = path.resolve(outputPath);
+      await fs.mkdir(path.dirname(resolvedPath), { recursive: true });
+      await fs.writeFile(resolvedPath, xml, "utf8");
+      return resolvedPath;
+    }
+    function registerSvgTool2(server2) {
+      server2.registerTool(
+        "convert-svg-to-android-drawable",
+        {
+          title: "SVG to VectorDrawable",
+          description: "Convert SVG markup or files into Android VectorDrawable XML quickly, optionally writing to disk.",
+          inputSchema: convertInputSchema
+        },
+        async (params, extra) => {
+          const svgCode = await loadSvg(params);
+          const options = {
+            floatPrecision: params.floatPrecision,
+            fillBlack: params.fillBlack,
+            xmlTag: params.xmlTag,
+            tint: params.tint
+          };
+          const cacheKey = makeCacheKey(svgCode, options);
+          const startTime = process.hrtime.bigint();
+          let xml = null;
+          if (params.cache) {
+            xml = getCached(cacheKey);
+          }
+          if (!xml) {
+            xml = await svg2vectordrawable(svgCode, options);
+            if (!xml || typeof xml !== "string") {
+              throw new Error("Conversion did not produce XML");
+            }
+            setCache(cacheKey, xml);
+          }
+          const savedPath = await maybeWriteOutput(params.outputPath, xml);
+          const elapsedMs = Number(process.hrtime.bigint() - startTime) / 1e6;
+          if (extra && typeof extra.sessionId === "string") {
+            server2.sendLoggingMessage(
+              {
+                level: "info",
+                data: `Converted SVG in ${elapsedMs.toFixed(2)}ms` + (savedPath ? ` (saved to ${savedPath})` : "")
+              },
+              extra.sessionId
+            ).catch(() => {
+            });
+          }
+          const content = [];
+          if (savedPath) {
+            content.push({ type: "text", text: `Saved VectorDrawable to ${savedPath}` });
+          }
+          content.push({ type: "text", text: xml });
+          return { content };
+        }
+      );
+    }
+    module2.exports = {
+      registerSvgTool: registerSvgTool2,
+      svgToolInstructions: svgToolInstructions2
+    };
+  }
+});
+
+// src/tools/logcatTool.js
+var require_logcatTool = __commonJS({
+  "src/tools/logcatTool.js"(exports2, module2) {
+    var { execFile } = require("child_process");
+    var { promisify } = require("util");
+    var z = require("zod/v4");
+    var execFileAsync = promisify(execFile);
+    var logcatToolInstructions2 = [
+      "Use read-adb-logcat to tail device logs for a package, pid, or tag; default tail=200 lines.",
+      "Use get-pid-by-package to resolve pid quickly via adb shell pidof -s.",
+      "Use get-current-activity to inspect current focus (Activity/Window) via dumpsys window.",
+      "Use fetch-crash-stacktrace to pull the latest crash buffer (-b crash) optionally filtered by pid.",
+      "Use check-anr-state to inspect ActivityManager ANR logs and /data/anr/traces.txt (best-effort).",
+      "Use clear-logcat-buffer to reset logcat (-c) before running new scenarios."
+    ].join("\n");
+    var logcatInputSchema = z.object({
+      packageName: z.string().min(1).describe("Android package name; resolves pid via adb shell pidof").optional(),
+      pid: z.string().min(1).describe("Explicit process id for logcat --pid").optional(),
+      tag: z.string().min(1).describe("Logcat tag to include (uses -s tag)").optional(),
+      priority: z.enum(["V", "D", "I", "W", "E", "F", "S"]).default("V").describe("Minimum priority when tag is provided (e.g., D for debug)"),
+      maxLines: z.number().int().min(1).max(2e3).default(200).describe("Tail line count via logcat -t"),
+      timeoutMs: z.number().int().min(1e3).max(15e3).default(5e3).describe("Timeout per adb call in milliseconds")
+    }).refine((data) => data.packageName || data.pid || data.tag, {
+      message: "Provide packageName, pid, or tag to avoid unfiltered logs"
+    });
+    var pidInputSchema = z.object({
+      packageName: z.string().min(1).describe("Android package name to resolve pid via adb shell pidof -s"),
+      timeoutMs: z.number().int().min(1e3).max(15e3).default(5e3).describe("Timeout per adb call in milliseconds")
+    });
+    var currentActivityInputSchema = z.object({
+      timeoutMs: z.number().int().min(1e3).max(15e3).default(5e3).describe("Timeout per adb call in milliseconds")
+    });
+    var crashStackInputSchema = z.object({
+      packageName: z.string().min(1).describe("Optional package to resolve pid; filters crash buffer with --pid").optional(),
+      maxLines: z.number().int().min(50).max(2e3).default(400).describe("Tail line count from crash buffer (-b crash -t)"),
+      timeoutMs: z.number().int().min(1e3).max(15e3).default(5e3).describe("Timeout per adb call in milliseconds")
+    });
+    var anrStateInputSchema = z.object({
+      maxLines: z.number().int().min(50).max(2e3).default(400).describe("Tail line count from ActivityManager:E"),
+      timeoutMs: z.number().int().min(1e3).max(15e3).default(5e3).describe("Timeout per adb call in milliseconds")
+    });
+    var clearLogcatInputSchema = z.object({
+      timeoutMs: z.number().int().min(1e3).max(15e3).default(5e3).describe("Timeout per adb call in milliseconds")
+    });
+    async function runAdbCommand(args, timeoutMs) {
+      try {
+        const { stdout } = await execFileAsync("adb", args, {
+          timeout: timeoutMs,
+          maxBuffer: 5 * 1024 * 1024
+        });
+        return stdout.trimEnd();
+      } catch (error) {
+        const stderr = error && typeof error.stderr === "string" ? error.stderr.trim() : "";
+        const message = [`adb ${args.join(" ")} failed`, error.message].filter(Boolean).join(": ");
+        if (stderr) {
+          throw new Error(`${message} | stderr: ${stderr}`);
+        }
+        throw new Error(message);
+      }
+    }
+    async function resolvePid(packageName, timeoutMs) {
+      const output = await runAdbCommand(["shell", "pidof", "-s", packageName], timeoutMs);
+      const pid = output.split(/\s+/).find(Boolean);
+      if (!pid) {
+        throw new Error(`Could not resolve pid for package ${packageName}`);
+      }
+      return pid;
+    }
+    function buildLogcatArgs(params, pid) {
+      const args = ["logcat", "-d", "-t", String(params.maxLines)];
+      if (pid) {
+        args.push(`--pid=${pid}`);
+      }
+      if (params.tag) {
+        const filterSpec = `${params.tag}:${params.priority}`;
+        args.push("-s", filterSpec);
+      }
+      return args;
+    }
+    function registerLogcatTool2(server2) {
+      server2.registerTool(
+        "read-adb-logcat",
+        {
+          title: "Read adb logcat",
+          description: "Dump recent adb logcat output scoped by package, pid, or tag with tail and timeout controls.",
+          inputSchema: logcatInputSchema
+        },
+        async (params, extra) => {
+          const timeoutMs = params.timeoutMs;
+          const pid = params.pid || (params.packageName ? await resolvePid(params.packageName, timeoutMs) : null);
+          const args = buildLogcatArgs(params, pid);
+          const startTime = process.hrtime.bigint();
+          const output = await runAdbCommand(args, timeoutMs);
+          const elapsedMs = Number(process.hrtime.bigint() - startTime) / 1e6;
+          if (extra && typeof extra.sessionId === "string") {
+            server2.sendLoggingMessage(
+              {
+                level: "info",
+                data: `Read logcat (${params.maxLines} lines` + (pid ? `, pid=${pid}` : "") + (params.tag ? `, tag=${params.tag}:${params.priority}` : "") + `) in ${elapsedMs.toFixed(2)}ms`
+              },
+              extra.sessionId
+            ).catch(() => {
+            });
+          }
+          if (!output) {
+            return { content: [{ type: "text", text: "Logcat returned no lines." }] };
+          }
+          return { content: [{ type: "text", text: output }] };
+        }
+      );
+      server2.registerTool(
+        "get-pid-by-package",
+        {
+          title: "Get pid by package",
+          description: "Resolve process id for a package via adb shell pidof -s.",
+          inputSchema: pidInputSchema
+        },
+        async (params) => {
+          const pid = await resolvePid(params.packageName, params.timeoutMs);
+          return { content: [{ type: "text", text: pid }] };
+        }
+      );
+      server2.registerTool(
+        "get-current-activity",
+        {
+          title: "Get current activity/window focus",
+          description: "Inspect current focused app/window via dumpsys window (mCurrentFocus/mFocusedApp). Useful even in single-activity apps to verify top window.",
+          inputSchema: currentActivityInputSchema
+        },
+        async (params) => {
+          const dump = await runAdbCommand(["shell", "dumpsys", "window"], params.timeoutMs);
+          const lines = dump.split("\n").filter((line) => line.includes("mCurrentFocus") || line.includes("mFocusedApp"));
+          const trimmed = lines.slice(0, 8).join("\n").trim();
+          if (!trimmed) {
+            return { content: [{ type: "text", text: "No focus info found in dumpsys window." }] };
+          }
+          return { content: [{ type: "text", text: trimmed }] };
+        }
+      );
+      server2.registerTool(
+        "fetch-crash-stacktrace",
+        {
+          title: "Fetch crash stacktrace (crash buffer)",
+          description: "Pull recent crash buffer (-b crash -d -t) optionally filtered by pid resolved from package.",
+          inputSchema: crashStackInputSchema
+        },
+        async (params) => {
+          const pid = params.packageName ? await resolvePid(params.packageName, params.timeoutMs) : null;
+          const args = ["logcat", "-b", "crash", "-d", "-t", String(params.maxLines)];
+          if (pid) {
+            args.push(`--pid=${pid}`);
+          }
+          const output = await runAdbCommand(args, params.timeoutMs);
+          if (!output) {
+            return { content: [{ type: "text", text: "No crash entries found." }] };
+          }
+          return { content: [{ type: "text", text: output }] };
+        }
+      );
+      server2.registerTool(
+        "check-anr-state",
+        {
+          title: "Check ANR state (ActivityManager + traces)",
+          description: "Check recent ActivityManager ANR logs and tail /data/anr/traces.txt when accessible (best-effort, may require root/debuggable).",
+          inputSchema: anrStateInputSchema
+        },
+        async (params) => {
+          const sections = [];
+          try {
+            const amLogs = await runAdbCommand(
+              ["logcat", "-d", "-t", String(params.maxLines), "ActivityManager:E", "*:S"],
+              params.timeoutMs
+            );
+            if (amLogs) {
+              sections.push("ActivityManager (recent):\n" + amLogs);
+            } else {
+              sections.push("ActivityManager (recent): no entries.");
+            }
+          } catch (error) {
+            sections.push(`ActivityManager: ${error.message}`);
+          }
+          try {
+            const stat = await runAdbCommand(["shell", "ls", "-l", "/data/anr/traces.txt"], params.timeoutMs);
+            sections.push("traces.txt stat:\n" + stat);
+          } catch (error) {
+            sections.push(`traces.txt stat: ${error.message}`);
+          }
+          try {
+            const tail = await runAdbCommand(
+              ["shell", "tail", "-n", "200", "/data/anr/traces.txt"],
+              params.timeoutMs
+            );
+            if (tail) {
+              sections.push("traces.txt tail (200 lines):\n" + tail);
+            } else {
+              sections.push("traces.txt tail: empty.");
+            }
+          } catch (error) {
+            sections.push(`traces.txt tail: ${error.message}`);
+          }
+          return { content: [{ type: "text", text: sections.join("\n\n") }] };
+        }
+      );
+      server2.registerTool(
+        "clear-logcat-buffer",
+        {
+          title: "Clear logcat buffer",
+          description: "Run adb logcat -c to clear buffers before a new scenario.",
+          inputSchema: clearLogcatInputSchema
+        },
+        async (params) => {
+          await runAdbCommand(["logcat", "-c"], params.timeoutMs);
+          return { content: [{ type: "text", text: "Cleared logcat buffers." }] };
+        }
+      );
+    }
+    module2.exports = {
+      registerLogcatTool: registerLogcatTool2,
+      logcatToolInstructions: logcatToolInstructions2
+    };
+  }
+});
+
+// src/index.js
+var { McpServer } = require("@modelcontextprotocol/sdk/server/mcp.js");
+var { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio.js");
+var { registerSvgTool, svgToolInstructions } = require_svgTool();
+var { registerLogcatTool, logcatToolInstructions } = require_logcatTool();
+var serverInstructions = [svgToolInstructions, logcatToolInstructions].join("\n");
+var server = new McpServer(
+  {
+    name: "svg-to-android-drawable",
+    version: "1.1.0"
+  },
+  {
+    capabilities: { logging: {} },
+    instructions: serverInstructions
+  }
+);
+registerSvgTool(server);
+registerLogcatTool(server);
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.stdin.resume();
+}
+main().catch((error) => {
+  console.error("Failed to start MCP server:", error);
+  process.exit(1);
+});