@8btc/ppt-generator-mcp 0.0.1

package/dist/utils/htmlParser/parser.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = exports.rewindStack = exports.hasTerminalParent = exports.parser = void 0;
+const tags_1 = require("./tags");
+const parser = (tokens) => {
+    const root = { tagName: null, children: [] };
+    const state = { tokens, cursor: 0, stack: [root] };
+    (0, exports.parse)(state);
+    return root.children;
+};
+exports.parser = parser;
+const hasTerminalParent = (tagName, stack) => {
+    const tagParents = tags_1.closingTagAncestorBreakers[tagName];
+    if (tagParents) {
+        let currentIndex = stack.length - 1;
+        while (currentIndex >= 0) {
+            const parentTagName = stack[currentIndex].tagName;
+            if (parentTagName === tagName)
+                break;
+            if (parentTagName && tagParents.includes(parentTagName))
+                return true;
+            currentIndex--;
+        }
+    }
+    return false;
+};
+exports.hasTerminalParent = hasTerminalParent;
+const rewindStack = (stack, newLength) => {
+    stack.splice(newLength);
+};
+exports.rewindStack = rewindStack;
+const parse = (state) => {
+    const { stack, tokens } = state;
+    let { cursor } = state;
+    let nodes = stack[stack.length - 1].children;
+    const len = tokens.length;
+    while (cursor < len) {
+        const token = tokens[cursor];
+        if (token.type !== "tag-start") {
+            nodes.push(token);
+            cursor++;
+            continue;
+        }
+        const tagToken = tokens[++cursor];
+        cursor++;
+        const tagName = tagToken.content.toLowerCase();
+        if (token.close) {
+            let index = stack.length;
+            let shouldRewind = false;
+            while (--index > -1) {
+                if (stack[index].tagName === tagName) {
+                    shouldRewind = true;
+                    break;
+                }
+            }
+            while (cursor < len) {
+                if (tokens[cursor].type !== "tag-end")
+                    break;
+                cursor++;
+            }
+            if (shouldRewind) {
+                (0, exports.rewindStack)(stack, index);
+                break;
+            }
+            else
+                continue;
+        }
+        const isClosingTag = tags_1.closingTags.includes(tagName);
+        let shouldRewindToAutoClose = isClosingTag;
+        if (shouldRewindToAutoClose) {
+            shouldRewindToAutoClose = !(0, exports.hasTerminalParent)(tagName, stack);
+        }
+        if (shouldRewindToAutoClose) {
+            let currentIndex = stack.length - 1;
+            while (currentIndex > 0) {
+                if (tagName === stack[currentIndex].tagName) {
+                    (0, exports.rewindStack)(stack, currentIndex);
+                    const previousIndex = currentIndex - 1;
+                    nodes = stack[previousIndex].children;
+                    break;
+                }
+                currentIndex = currentIndex - 1;
+            }
+        }
+        const attributes = [];
+        let tagEndToken;
+        while (cursor < len) {
+            const _token = tokens[cursor];
+            if (_token.type === "tag-end") {
+                tagEndToken = _token;
+                break;
+            }
+            attributes.push(_token.content);
+            cursor++;
+        }
+        if (!tagEndToken)
+            break;
+        cursor++;
+        const children = [];
+        const elementNode = {
+            type: "element",
+            tagName: tagToken.content,
+            attributes,
+            children,
+        };
+        nodes.push(elementNode);
+        const hasChildren = !(tagEndToken.close || tags_1.voidTags.includes(tagName));
+        if (hasChildren) {
+            stack.push({ tagName, children });
+            const innerState = { tokens, cursor, stack };
+            (0, exports.parse)(innerState);
+            cursor = innerState.cursor;
+        }
+    }
+    state.cursor = cursor;
+};
+exports.parse = parse;

package/dist/utils/htmlParser/stringify.d.ts

@@ -0,0 +1,3 @@
+import type { AST, ElementAttribute } from "./types";
+export declare const formatAttributes: (attributes: ElementAttribute[]) => string;
+export declare const toHTML: (tree: AST[]) => string;

package/dist/utils/htmlParser/stringify.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHTML = exports.formatAttributes = void 0;
+const tags_1 = require("./tags");
+const formatAttributes = (attributes) => {
+    return attributes.reduce((attrs, attribute) => {
+        const { key, value } = attribute;
+        if (value === null)
+            return `${attrs} ${key}`;
+        if (key === "style" && !value)
+            return "";
+        const quoteEscape = value.indexOf("'") !== -1;
+        const quote = quoteEscape ? '"' : "'";
+        return `${attrs} ${key}=${quote}${value}${quote}`;
+    }, "");
+};
+exports.formatAttributes = formatAttributes;
+const toHTML = (tree) => {
+    const htmlStrings = tree.map((node) => {
+        if (node.type === "text")
+            return node.content;
+        if (node.type === "comment")
+            return `<!--${node.content}-->`;
+        const { tagName, attributes, children } = node;
+        const isSelfClosing = tags_1.voidTags.includes(tagName.toLowerCase());
+        if (isSelfClosing)
+            return `<${tagName}${(0, exports.formatAttributes)(attributes)}>`;
+        return `<${tagName}${(0, exports.formatAttributes)(attributes)}>${(0, exports.toHTML)(children)}</${tagName}>`;
+    });
+    return htmlStrings.join("");
+};
+exports.toHTML = toHTML;

package/dist/utils/htmlParser/tags.d.ts

@@ -0,0 +1,8 @@
+export declare const childlessTags: string[];
+export declare const closingTags: string[];
+interface ClosingTagAncestorBreakers {
+    [key: string]: string[];
+}
+export declare const closingTagAncestorBreakers: ClosingTagAncestorBreakers;
+export declare const voidTags: string[];
+export {};

package/dist/utils/htmlParser/tags.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.voidTags = exports.closingTagAncestorBreakers = exports.closingTags = exports.childlessTags = void 0;
+exports.childlessTags = ["style", "script", "template"];
+exports.closingTags = [
+    "html",
+    "head",
+    "body",
+    "p",
+    "dt",
+    "dd",
+    "li",
+    "option",
+    "thead",
+    "th",
+    "tbody",
+    "tr",
+    "td",
+    "tfoot",
+    "colgroup",
+];
+exports.closingTagAncestorBreakers = {
+    li: ["ul", "ol", "menu"],
+    dt: ["dl"],
+    dd: ["dl"],
+    tbody: ["table"],
+    thead: ["table"],
+    tfoot: ["table"],
+    tr: ["table"],
+    td: ["table"],
+};
+exports.voidTags = [
+    "!doctype",
+    "area",
+    "base",
+    "br",
+    "col",
+    "command",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "keygen",
+    "link",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr",
+];

package/dist/utils/htmlParser/types.d.ts

@@ -0,0 +1,55 @@
+export interface ElementAttribute {
+    key: string;
+    value: string | null;
+}
+export interface CommentElement {
+    type: "comment";
+    content: string;
+}
+export interface TextElement {
+    type: "text";
+    content: string;
+}
+export interface NormalElement {
+    type: "element";
+    tagName: string;
+    children: HTMLNode[];
+    attributes: string[];
+}
+export type HTMLNode = CommentElement | TextElement | NormalElement;
+export interface ElementAST {
+    type: "element";
+    tagName: string;
+    children: AST[];
+    attributes: ElementAttribute[];
+}
+export interface CommentOrTextAST {
+    type: "comment" | "text";
+    content: string;
+}
+export type AST = CommentOrTextAST | ElementAST;
+export interface TagStartToken {
+    type: "tag-start";
+    close: boolean;
+}
+export interface TagEndToken {
+    type: "tag-end";
+    close: boolean;
+}
+export interface TagToken {
+    type: "tag";
+    content: string;
+}
+export interface TextToken {
+    type: "text";
+    content: string;
+}
+export interface CommentToken {
+    type: "comment";
+    content: string;
+}
+export interface AttributeToken {
+    type: "attribute";
+    content: string;
+}
+export type Token = TagStartToken | TagEndToken | TagToken | TextToken | CommentToken | AttributeToken;

package/dist/utils/htmlParser/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/svg2Base64.d.ts

@@ -0,0 +1 @@
+export declare const svg2Base64: (element: Element) => string;

package/dist/utils/svg2Base64.js

@@ -0,0 +1,58 @@
+"use strict";
+// svg转base64图片，参考：https://github.com/scriptex/svg64
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.svg2Base64 = void 0;
+const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+const PREFIX = "data:image/svg+xml;base64,";
+const utf8Encode = (string) => {
+    string = string.replace(/\r\n/g, "\n");
+    let utftext = "";
+    for (let n = 0; n < string.length; n++) {
+        const c = string.charCodeAt(n);
+        if (c < 128) {
+            utftext += String.fromCharCode(c);
+        }
+        else if (c > 127 && c < 2048) {
+            utftext += String.fromCharCode((c >> 6) | 192);
+            utftext += String.fromCharCode((c & 63) | 128);
+        }
+        else {
+            utftext += String.fromCharCode((c >> 12) | 224);
+            utftext += String.fromCharCode(((c >> 6) & 63) | 128);
+            utftext += String.fromCharCode((c & 63) | 128);
+        }
+    }
+    return utftext;
+};
+const encode = (input) => {
+    let output = "";
+    let chr1, chr2, chr3, enc1, enc2, enc3, enc4;
+    let i = 0;
+    input = utf8Encode(input);
+    while (i < input.length) {
+        chr1 = input.charCodeAt(i++);
+        chr2 = input.charCodeAt(i++);
+        chr3 = input.charCodeAt(i++);
+        enc1 = chr1 >> 2;
+        enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+        enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
+        enc4 = chr3 & 63;
+        if (isNaN(chr2))
+            enc3 = enc4 = 64;
+        else if (isNaN(chr3))
+            enc4 = 64;
+        output =
+            output +
+                characters.charAt(enc1) +
+                characters.charAt(enc2) +
+                characters.charAt(enc3) +
+                characters.charAt(enc4);
+    }
+    return output;
+};
+const svg2Base64 = (element) => {
+    const XMLS = new XMLSerializer();
+    const svg = XMLS.serializeToString(element);
+    return PREFIX + encode(svg);
+};
+exports.svg2Base64 = svg2Base64;

package/dist/utils/svgPathParser.d.ts

@@ -0,0 +1,120 @@
+/**
+ * 简单解析SVG路径
+ * @param d SVG path d属性
+ */
+export declare const parseSvgPath: (d: string) => ({
+    type: string;
+    relative: boolean;
+    x: number;
+    y: number;
+} | {
+    type: string;
+    relative: boolean;
+    x: number;
+    y: number;
+} | {
+    type: string;
+    relative: boolean;
+    x: number;
+} | {
+    type: string;
+    relative: boolean;
+    y: number;
+} | {
+    type: string;
+} | {
+    type: string;
+    relative: boolean;
+    x1: number;
+    y1: number;
+    x: number;
+    y: number;
+} | {
+    type: string;
+    relative: boolean;
+    x: number;
+    y: number;
+} | {
+    type: string;
+    relative: boolean;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    x: number;
+    y: number;
+} | {
+    type: string;
+    relative: boolean;
+    x2: number;
+    y2: number;
+    x: number;
+    y: number;
+} | {
+    type: string;
+    relative: boolean;
+    rX: number;
+    rY: number;
+    xRot: number;
+    sweepFlag: 0 | 1;
+    lArcFlag: 0 | 1;
+    x: number;
+    y: number;
+    cX?: number;
+    cY?: number;
+    phi1?: number;
+    phi2?: number;
+})[];
+export type SvgPath = ReturnType<typeof parseSvgPath>;
+/**
+ * 解析SVG路径，并将圆弧（A）类型的路径转为三次贝塞尔（C）类型的路径
+ * @param d SVG path d属性
+ */
+export declare const toPoints: (d: string) => ({
+    x: number;
+    y: number;
+    relative: boolean;
+    type: string;
+    curve?: undefined;
+    close?: undefined;
+} | {
+    x: number;
+    y: number;
+    curve: {
+        type: string;
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    };
+    relative: boolean;
+    type: string;
+    close?: undefined;
+} | {
+    x: number;
+    y: number;
+    curve: {
+        type: string;
+        x1: number;
+        y1: number;
+        x2?: undefined;
+        y2?: undefined;
+    };
+    relative: boolean;
+    type: string;
+    close?: undefined;
+} | {
+    close: boolean;
+    type: string;
+    x?: undefined;
+    y?: undefined;
+    relative?: undefined;
+    curve?: undefined;
+})[];
+export declare const getSvgPathRange: (path: string) => {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+};
+export type SvgPoints = ReturnType<typeof toPoints>;

package/dist/utils/svgPathParser.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSvgPathRange = exports.toPoints = exports.parseSvgPath = void 0;
+const svg_pathdata_1 = require("svg-pathdata");
+const svg_arc_to_cubic_bezier_1 = __importDefault(require("svg-arc-to-cubic-bezier"));
+const typeMap = {
+    1: "Z",
+    2: "M",
+    4: "H",
+    8: "V",
+    16: "L",
+    32: "C",
+    64: "S",
+    128: "Q",
+    256: "T",
+    512: "A",
+};
+/**
+ * 简单解析SVG路径
+ * @param d SVG path d属性
+ */
+const parseSvgPath = (d) => {
+    const pathData = new svg_pathdata_1.SVGPathData(d);
+    const ret = pathData.commands.map((item) => {
+        return { ...item, type: typeMap[item.type] };
+    });
+    return ret;
+};
+exports.parseSvgPath = parseSvgPath;
+/**
+ * 解析SVG路径，并将圆弧（A）类型的路径转为三次贝塞尔（C）类型的路径
+ * @param d SVG path d属性
+ */
+const toPoints = (d) => {
+    const pathData = new svg_pathdata_1.SVGPathData(d);
+    const points = [];
+    for (const item of pathData.commands) {
+        const type = typeMap[item.type];
+        if (item.type === 2 || item.type === 16) {
+            points.push({
+                x: item.x,
+                y: item.y,
+                relative: item.relative,
+                type,
+            });
+        }
+        if (item.type === 32) {
+            points.push({
+                x: item.x,
+                y: item.y,
+                curve: {
+                    type: "cubic",
+                    x1: item.x1,
+                    y1: item.y1,
+                    x2: item.x2,
+                    y2: item.y2,
+                },
+                relative: item.relative,
+                type,
+            });
+        }
+        else if (item.type === 128) {
+            points.push({
+                x: item.x,
+                y: item.y,
+                curve: {
+                    type: "quadratic",
+                    x1: item.x1,
+                    y1: item.y1,
+                },
+                relative: item.relative,
+                type,
+            });
+        }
+        else if (item.type === 512) {
+            const lastPoint = points[points.length - 1];
+            if (!["M", "L", "Q", "C"].includes(lastPoint.type))
+                continue;
+            const cubicBezierPoints = (0, svg_arc_to_cubic_bezier_1.default)({
+                px: lastPoint.x,
+                py: lastPoint.y,
+                cx: item.x,
+                cy: item.y,
+                rx: item.rX,
+                ry: item.rY,
+                xAxisRotation: item.xRot,
+                largeArcFlag: item.lArcFlag,
+                sweepFlag: item.sweepFlag,
+            });
+            for (const cbPoint of cubicBezierPoints) {
+                points.push({
+                    x: cbPoint.x,
+                    y: cbPoint.y,
+                    curve: {
+                        type: "cubic",
+                        x1: cbPoint.x1,
+                        y1: cbPoint.y1,
+                        x2: cbPoint.x2,
+                        y2: cbPoint.y2,
+                    },
+                    relative: false,
+                    type: "C",
+                });
+            }
+        }
+        else if (item.type === 1) {
+            points.push({ close: true, type });
+        }
+        else
+            continue;
+    }
+    return points;
+};
+exports.toPoints = toPoints;
+const getSvgPathRange = (path) => {
+    try {
+        const pathData = new svg_pathdata_1.SVGPathData(path);
+        const xList = [];
+        const yList = [];
+        for (const item of pathData.commands) {
+            const x = "x" in item ? item.x : 0;
+            const y = "y" in item ? item.y : 0;
+            xList.push(x);
+            yList.push(y);
+        }
+        return {
+            minX: Math.min(...xList),
+            minY: Math.min(...yList),
+            maxX: Math.max(...xList),
+            maxY: Math.max(...yList),
+        };
+    }
+    catch {
+        return {
+            minX: 0,
+            minY: 0,
+            maxX: 0,
+            maxY: 0,
+        };
+    }
+};
+exports.getSvgPathRange = getSvgPathRange;

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@8btc/ppt-generator-mcp",
+  "version": "0.0.1",
+  "description": "MCP service for generating PPT files from AI-generated outlines and templates",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc && cp -r src/tpls dist",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "test": "npm run build && node test/test-gen-ppt.cjs",
+    "release": "npm run build && npm publish --access public"
+  },
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "@8btc/ppt-generator-mcp": "dist/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "ppt",
+    "powerpoint",
+    "generator",
+    "ai"
+  ],
+  "author": "PPT Agent",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.18.1",
+    "@napi-rs/canvas": "^0.1.80",
+    "@types/jsdom": "^21.1.7",
+    "fs-extra": "^11.2.0",
+    "himalaya": "^1.1.1",
+    "jsdom": "^27.0.0",
+    "lodash": "^4.17.21",
+    "nanoid": "^5.1.6",
+    "path": "^0.12.7",
+    "pptxgenjs": "^3.12.0",
+    "svg-arc-to-cubic-bezier": "^3.2.0",
+    "svg-pathdata": "^8.0.0",
+    "tinycolor2": "^1.6.0",
+    "uuid": "^9.0.1"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/jest": "^29.0.0",
+    "@types/lodash": "^4.17.20",
+    "@types/node": "^20.0.0",
+    "@types/svg-arc-to-cubic-bezier": "^3.2.3",
+    "@types/tinycolor2": "^1.4.6",
+    "@types/uuid": "^9.0.0",
+    "jest": "^29.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}