trace.moe-mcp 1.0.0 → 1.0.2

package/dist/src/image-processor.js

@@ -0,0 +1,219 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import sharp from "sharp";
+import { ColorLayout } from "trace.moe-id";
+sharp.cache(false);
+sharp.concurrency(1);
+function getVideoFrameRect(data, width, height, channels = 3, colorTolerance = 10) {
+    function isDark(x, y) {
+        const i = (y * width + x) * channels;
+        return (data[i] <= colorTolerance && data[i + 1] <= colorTolerance && data[i + 2] <= colorTolerance);
+    }
+    function isRowDark(y) {
+        let darkPixelCount = 0;
+        for (let x = 0; x < width; x++) {
+            if (isDark(x, y))
+                darkPixelCount++;
+        }
+        return darkPixelCount > width * 0.95;
+    }
+    function isColDark(x) {
+        let darkPixelCount = 0;
+        for (let y = 0; y < height; y++) {
+            if (isDark(x, y))
+                darkPixelCount++;
+        }
+        return darkPixelCount > height * 0.95;
+    }
+    let top, bottom, left, right;
+    const centerY = Math.floor(height / 2);
+    const centerX = Math.floor(width / 2);
+    if (!isDark(centerX, centerY)) {
+        top = centerY;
+        bottom = centerY;
+        left = centerX;
+        right = centerX;
+        while (top > 0 && !isRowDark(top - 1))
+            top--;
+        while (bottom < height - 1 && !isRowDark(bottom + 1))
+            bottom++;
+        while (left > 0 && !isColDark(left - 1))
+            left--;
+        while (right < width - 1 && !isColDark(right + 1))
+            right++;
+    }
+    else {
+        top = 0;
+        bottom = height - 1;
+        left = 0;
+        right = width - 1;
+        while (top < height && isRowDark(top))
+            top++;
+        while (bottom > top && isRowDark(bottom))
+            bottom--;
+        while (left < width && isColDark(left))
+            left++;
+        while (right > left && isColDark(right))
+            right--;
+    }
+    return {
+        x: left,
+        y: top,
+        width: Math.max(1, right - left + 1),
+        height: Math.max(1, bottom - top + 1),
+    };
+}
+function getNearestAspectRatio(width, height, targetAspectRatios, threshold = 0.05) {
+    const aspectRatio = width / height;
+    let bestRatio = null;
+    let minDiff = Infinity;
+    for (const targetRatio of targetAspectRatios) {
+        const diff = Math.abs(aspectRatio - targetRatio);
+        if (diff < minDiff) {
+            minDiff = diff;
+            bestRatio = targetRatio;
+        }
+    }
+    if (minDiff <= threshold) {
+        return bestRatio;
+    }
+    return null;
+}
+function snapRectToNearestAspectRatio(rect, maxW, maxH) {
+    const targetRatios = [4 / 3, 16 / 9, 21 / 9];
+    const currentRatio = rect.width / (rect.height || 1);
+    let R = targetRatios[0];
+    let minDiff = Math.abs(currentRatio - R);
+    for (let i = 1; i < targetRatios.length; i++) {
+        const diff = Math.abs(currentRatio - targetRatios[i]);
+        if (diff < minDiff) {
+            minDiff = diff;
+            R = targetRatios[i];
+        }
+    }
+    let w = rect.width;
+    let h = rect.height;
+    if (w / R > h) {
+        w = h * R;
+    }
+    else {
+        h = w / R;
+    }
+    if (w < 10)
+        w = 10;
+    if (h < 10)
+        h = 10;
+    const cx = rect.x + rect.width / 2;
+    const cy = rect.y + rect.height / 2;
+    let x = cx - w / 2;
+    let y = cy - h / 2;
+    if (x < 0)
+        x = 0;
+    if (y < 0)
+        y = 0;
+    if (x + w > maxW) {
+        x = maxW - w;
+        if (x < 0) {
+            x = 0;
+            w = maxW;
+        }
+    }
+    if (y + h > maxH) {
+        y = maxH - h;
+        if (y < 0) {
+            y = 0;
+            h = maxH;
+        }
+    }
+    return {
+        x: Math.round(x),
+        y: Math.round(y),
+        width: Math.round(w),
+        height: Math.round(h),
+    };
+}
+/**
+ * Resizes and optionally crops black borders from an image buffer,
+ * returning raw RGB pixel data and dimensions.
+ */
+export async function resizeAndCropImage(imageBuffer, cutBorders = true) {
+    const resized = await sharp(imageBuffer)
+        .resize({ width: 320, height: 320, fit: "inside" })
+        .toBuffer();
+    let cropped = sharp(resized);
+    if (cutBorders) {
+        try {
+            const { data, info } = await sharp(resized)
+                .removeAlpha()
+                .raw()
+                .toBuffer({ resolveWithObject: true });
+            const targetRatios = [4 / 3, 16 / 9, 21 / 9];
+            const matchedRatio = getNearestAspectRatio(info.width, info.height, targetRatios);
+            if (matchedRatio === null) {
+                const detected = getVideoFrameRect(data, info.width, info.height, 3, 10);
+                const snapped = snapRectToNearestAspectRatio(detected, info.width, info.height);
+                cropped = sharp(resized).extract({
+                    left: snapped.x,
+                    top: snapped.y,
+                    width: snapped.width,
+                    height: snapped.height,
+                });
+            }
+        }
+        catch {
+            // If border trimming fails, fallback to uncropped resized image
+            cropped = sharp(resized);
+        }
+    }
+    const { data, info } = await cropped
+        .flatten({ background: "#000000" })
+        .removeAlpha()
+        .raw()
+        .toBuffer({ resolveWithObject: true });
+    return {
+        data,
+        width: info.width,
+        height: info.height,
+    };
+}
+/**
+ * Extracts the 33-element MPEG-7 Color Layout Vector from an image buffer.
+ */
+export async function extractVectorFromBuffer(imageBuffer, cutBorders = true) {
+    const { data, width, height } = await resizeAndCropImage(imageBuffer, cutBorders);
+    return ColorLayout.extract({ data, width, height, channels: 3 });
+}
+/**
+ * Resolves an image input (URL, local file path, or Base64 string) to a Buffer.
+ */
+export async function resolveImageInputToBuffer(input) {
+    if (input.imageBase64) {
+        // Strip data URL prefix if present (e.g. data:image/jpeg;base64,...)
+        const cleanBase64 = input.imageBase64.replace(/^data:image\/[a-z]+;base64,/, "");
+        return Buffer.from(cleanBase64, "base64");
+    }
+    if (input.filePath) {
+        const resolvedPath = path.resolve(input.filePath);
+        return await fs.readFile(resolvedPath);
+    }
+    if (input.url) {
+        const response = await fetch(input.url, {
+            headers: {
+                "User-Agent": "trace.moe-mcp/1.0.0",
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch image from URL: ${response.status} ${response.statusText}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        return Buffer.from(arrayBuffer);
+    }
+    throw new Error("No image source provided. Must provide url, filePath, or imageBase64.");
+}
+/**
+ * High-level helper to process an image input directly into a 33-element vector.
+ */
+export async function processImageToVector(input, cutBorders = true) {
+    const buffer = await resolveImageInputToBuffer(input);
+    return extractVectorFromBuffer(buffer, cutBorders);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trace.moe-mcp",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Model Context Protocol (MCP) server for trace.moe anime scene search",
   "keywords": [
     "anime",
@@ -18,16 +18,17 @@
     "url": "git+https://github.com/soruly/trace.moe-mcp.git"
   },
   "bin": {
-    "trace.moe-mcp": "./index.ts"
+    "tracemoe-mcp": "./dist/index.js"
   },
   "files": [
-    "index.ts",
-    "src"
+    "dist"
   ],
   "type": "module",
-  "main": "index.ts",
+  "main": "./dist/index.js",
   "scripts": {
-    "start": "node index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build && npm test",
     "format": "oxfmt",
     "lint": "oxlint",
     "lint:fix": "oxlint --fix",
@@ -43,7 +44,8 @@
     "@types/node": "^26.5.1",
     "@types/sharp": "^0.31.1",
     "oxfmt": "^0.67.0",
-    "oxlint": "^1.82.0"
+    "oxlint": "^1.82.0",
+    "typescript": "^7.0.2"
   },
   "engines": {
     "node": ">=24"

package/index.ts

@@ -1,370 +0,0 @@
-#!/usr/bin/env node
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-
-import { defaultClient } from "./src/api.ts";
-import {
-  formatAnilistSearchResultsMarkdown,
-  formatSearchResultsMarkdown,
-  formatUserQuotaMarkdown,
-} from "./src/format.ts";
-import { processImageToVector } from "./src/image-processor.ts";
-
-const server = new McpServer({
-  name: "trace.moe-mcp",
-  version: "1.0.0",
-});
-
-// Tool: Search Anime by Image URL (with local vector preprocessing)
-server.registerTool(
-  "search_anime_by_image_url",
-  {
-    title: "Search Anime by Image URL",
-    description:
-      "Search anime scene by image URL. Pre-processes the image locally into a 33-element Color Layout Descriptor vector and sends only the vector to api.trace.moe.",
-    inputSchema: {
-      url: z.url().describe("Direct HTTP/HTTPS URL of the anime screenshot"),
-      cutBorders: z
-        .boolean()
-        .optional()
-        .default(true)
-        .describe("Automatically crop black letterbox or pillarbox borders before searching"),
-      anilistInfo: z
-        .boolean()
-        .optional()
-        .default(true)
-        .describe("Include full anime titles and metadata"),
-      anilistID: z
-        .number()
-        .int()
-        .positive()
-        .optional()
-        .describe("Optional Anilist ID to filter search results within a specific anime"),
-    },
-  },
-  async ({ url, cutBorders, anilistInfo, anilistID }) => {
-    try {
-      const vector = await processImageToVector({ url }, cutBorders);
-      const searchResult = await defaultClient.searchByVector(vector, {
-        anilistInfo,
-        anilistID,
-      });
-
-      const markdown = formatSearchResultsMarkdown(searchResult);
-
-      return {
-        content: [
-          {
-            type: "text",
-            text: markdown,
-          },
-          {
-            type: "text",
-            text: JSON.stringify(searchResult, null, 2),
-          },
-        ],
-      };
-    } catch (error) {
-      return {
-        isError: true,
-        content: [
-          {
-            type: "text",
-            text: `Failed to search anime by image URL: ${error instanceof Error ? error.message : String(error)}`,
-          },
-        ],
-      };
-    }
-  },
-);
-
-// Tool: Search Anime by Local File or Base64 Image
-server.registerTool(
-  "search_anime_by_image_file",
-  {
-    title: "Search Anime by Image File or Base64",
-    description:
-      "Search anime scene from a local file path or base64 encoded image. Pre-processes the image locally into a 33-element vector and sends only the vector to api.trace.moe.",
-    inputSchema: {
-      filePath: z
-        .string()
-        .optional()
-        .describe("Local absolute or relative filesystem path to the image file"),
-      imageBase64: z
-        .string()
-        .optional()
-        .describe("Base64-encoded image string (with or without data URI scheme prefix)"),
-      cutBorders: z
-        .boolean()
-        .optional()
-        .default(true)
-        .describe("Automatically crop black letterbox or pillarbox borders before searching"),
-      anilistInfo: z
-        .boolean()
-        .optional()
-        .default(true)
-        .describe("Include full anime titles and metadata"),
-      anilistID: z
-        .number()
-        .int()
-        .positive()
-        .optional()
-        .describe("Optional Anilist ID to filter search results within a specific anime"),
-    },
-  },
-  async ({ filePath, imageBase64, cutBorders, anilistInfo, anilistID }) => {
-    try {
-      if (!filePath && !imageBase64) {
-        throw new Error("Must provide either 'filePath' or 'imageBase64'.");
-      }
-
-      const vector = await processImageToVector({ filePath, imageBase64 }, cutBorders);
-      const searchResult = await defaultClient.searchByVector(vector, {
-        anilistInfo,
-        anilistID,
-      });
-
-      const markdown = formatSearchResultsMarkdown(searchResult);
-
-      return {
-        content: [
-          {
-            type: "text",
-            text: markdown,
-          },
-          {
-            type: "text",
-            text: JSON.stringify(searchResult, null, 2),
-          },
-        ],
-      };
-    } catch (error) {
-      return {
-        isError: true,
-        content: [
-          {
-            type: "text",
-            text: `Failed to search anime by image file: ${error instanceof Error ? error.message : String(error)}`,
-          },
-        ],
-      };
-    }
-  },
-);
-
-// Tool: Search Anime by 33-element Color Layout Vector
-server.registerTool(
-  "search_anime_by_vector",
-  {
-    title: "Search Anime by Color Layout Vector",
-    description:
-      "Search anime scene directly using a 33-element MPEG-7 Color Layout Descriptor vector.",
-    inputSchema: {
-      vector: z
-        .array(z.number())
-        .length(33)
-        .describe("33-element integer vector representing MPEG-7 Color Layout Descriptor"),
-      anilistInfo: z
-        .boolean()
-        .optional()
-        .default(true)
-        .describe("Include full anime titles and metadata"),
-      anilistID: z
-        .number()
-        .int()
-        .positive()
-        .optional()
-        .describe("Optional Anilist ID to filter search results within a specific anime"),
-    },
-  },
-  async ({ vector, anilistInfo, anilistID }) => {
-    try {
-      const searchResult = await defaultClient.searchByVector(vector, {
-        anilistInfo,
-        anilistID,
-      });
-
-      const markdown = formatSearchResultsMarkdown(searchResult);
-
-      return {
-        content: [
-          {
-            type: "text",
-            text: markdown,
-          },
-          {
-            type: "text",
-            text: JSON.stringify(searchResult, null, 2),
-          },
-        ],
-      };
-    } catch (error) {
-      return {
-        isError: true,
-        content: [
-          {
-            type: "text",
-            text: `Failed to search anime by vector: ${error instanceof Error ? error.message : String(error)}`,
-          },
-        ],
-      };
-    }
-  },
-);
-
-// Tool: Search Anime by Name
-server.registerTool(
-  "search_anime_by_name",
-  {
-    title: "Search Anime by Name",
-    description:
-      "Search anime titles, romanized names, and synonyms using trace.moe Anilist database to retrieve Anilist IDs and metadata.",
-    inputSchema: {
-      query: z
-        .string()
-        .min(1)
-        .describe("Anime name, Chinese name, Japanese name, or keyword to search"),
-    },
-  },
-  async ({ query }) => {
-    try {
-      const results = await defaultClient.searchAnilist(query);
-      const markdown = formatAnilistSearchResultsMarkdown(results, query);
-
-      return {
-        content: [
-          {
-            type: "text",
-            text: markdown,
-          },
-          {
-            type: "text",
-            text: JSON.stringify(results, null, 2),
-          },
-        ],
-      };
-    } catch (error) {
-      return {
-        isError: true,
-        content: [
-          {
-            type: "text",
-            text: `Failed to search anime by name: ${error instanceof Error ? error.message : String(error)}`,
-          },
-        ],
-      };
-    }
-  },
-);
-
-// Tool: Get Account Quota & Concurrency
-server.registerTool(
-  "get_account_quota",
-  {
-    title: "Get Account Quota & Concurrency",
-    description:
-      "Check remaining daily search quota, concurrency limit, and priority for the current IP / API key on trace.moe.",
-    inputSchema: {},
-  },
-  async () => {
-    try {
-      const user = await defaultClient.getMe();
-      const markdown = formatUserQuotaMarkdown(user);
-      return {
-        content: [
-          {
-            type: "text",
-            text: markdown,
-          },
-          {
-            type: "text",
-            text: JSON.stringify(user, null, 2),
-          },
-        ],
-      };
-    } catch (error) {
-      return {
-        isError: true,
-        content: [
-          {
-            type: "text",
-            text: `Failed to get quota: ${error instanceof Error ? error.message : String(error)}`,
-          },
-        ],
-      };
-    }
-  },
-);
-
-// Resource: tracemoe://me
-server.registerResource(
-  "user-quota",
-  "tracemoe://me",
-  {
-    mimeType: "application/json",
-    description: "Current trace.moe search quota, limits, and usage",
-  },
-  async () => {
-    const user = await defaultClient.getMe();
-    return {
-      contents: [
-        {
-          uri: "tracemoe://me",
-          mimeType: "application/json",
-          text: JSON.stringify(user, null, 2),
-        },
-      ],
-    };
-  },
-);
-
-// Prompt: trace_moe
-server.registerPrompt(
-  "trace_moe",
-  {
-    title: "Trace Anime Scene",
-    description:
-      "Guide the model on identifying an anime screenshot scene using trace.moe and presenting accurate information.",
-    argsSchema: {
-      imageUrl: z.string().optional().describe("URL of the anime scene image to identify"),
-      filePath: z
-        .string()
-        .optional()
-        .describe("Local file path of the anime scene image to identify"),
-      notes: z.string().optional().describe("Additional clues or context"),
-    },
-  },
-  ({ imageUrl, filePath, notes }) => {
-    const promptText = `Please identify the anime scene from the provided image ${imageUrl ? `at ${imageUrl}` : ""}${filePath ? `(file: ${filePath})` : ""}.${notes ? ` Additional context: ${notes}` : ""}
-
-Steps to follow:
-1. Use the 'search_anime_by_image_url' or 'search_anime_by_image_file' tool to search trace.moe.
-2. If similarity is >= 85%, report the matched Anime Title (English, Romaji, and Native Japanese), Episode number, and exact timestamp (e.g. 00:12:34).
-3. Include the Anilist link and preview thumbnail / video clip URL for verification.
-4. If similarity is low (< 80%), warn the user that the match might be uncertain.`;
-
-    return {
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: promptText,
-          },
-        },
-      ],
-    };
-  },
-);
-
-// Start server using Stdio transport
-async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}
-
-main().catch((err) => {
-  console.error("Fatal error running trace.moe MCP server:", err);
-  process.exit(1);
-});