ani-mcp 0.5.1 → 0.6.0

package/README.md

@@ -126,6 +126,30 @@ Works with any MCP-compatible client.
 | `anilist_rate` | Score a title (0-10) |
 | `anilist_delete_from_list` | Remove an entry from your list |
 
+## Resources
+
+MCP resources provide context to your AI assistant without needing a tool call. Clients that support resources can automatically include this information in conversations.
+
+| Resource | Description |
+| --- | --- |
+| `anilist://profile` | Your AniList profile with bio, stats, and favourites |
+| `anilist://taste/{type}` | Taste profile (genre weights, themes, scoring patterns) for ANIME or MANGA |
+| `anilist://list/{type}` | Currently watching/reading entries with progress and scores |
+
+## Prompts
+
+Pre-built conversation starters that clients can offer as quick actions.
+
+| Prompt | Description |
+| --- | --- |
+| `seasonal_review` | Review this season's anime against your taste profile |
+| `what_to_watch` | Plan what to watch now with optional mood and time budget |
+| `roast_my_taste` | Get a humorous roast of your anime taste |
+| `compare_us` | Compare your taste with another user |
+| `year_in_review` | Your anime/manga year in review |
+| `explain_title` | Why would you like (or dislike) a specific title? |
+| `find_similar` | Find titles similar to one you enjoyed |
+
 ## Examples
 
 Here are some things you can ask your AI assistant once ani-mcp is connected:

package/dist/index.js

@@ -9,6 +9,8 @@ import { registerDiscoverTools } from "./tools/discover.js";
 import { registerInfoTools } from "./tools/info.js";
 import { registerWriteTools } from "./tools/write.js";
 import { registerSocialTools } from "./tools/social.js";
+import { registerResources } from "./resources.js";
+import { registerPrompts } from "./prompts.js";
 // Both vars are optional - warn on missing so operators know what's available
 if (!process.env.ANILIST_USERNAME) {
     console.warn("ANILIST_USERNAME not set - tools will require a username argument.");
@@ -18,7 +20,7 @@ if (!process.env.ANILIST_TOKEN) {
 }
 const server = new FastMCP({
     name: "ani-mcp",
-    version: "0.5.1",
+    version: "0.6.0",
 });
 registerSearchTools(server);
 registerListTools(server);
@@ -27,6 +29,8 @@ registerDiscoverTools(server);
 registerInfoTools(server);
 registerWriteTools(server);
 registerSocialTools(server);
+registerResources(server);
+registerPrompts(server);
 // === Transport ===
 const transport = process.env.MCP_TRANSPORT === "http" ? "httpStream" : "stdio";
 if (transport === "httpStream") {

package/dist/prompts.d.ts

@@ -0,0 +1,4 @@
+/** MCP Prompts: pre-built conversation starters */
+import type { FastMCP } from "fastmcp";
+/** Register MCP prompts on the server */
+export declare function registerPrompts(server: FastMCP): void;

package/dist/prompts.js

@@ -0,0 +1,205 @@
+/** MCP Prompts: pre-built conversation starters */
+import { resolveSeasonYear } from "./utils.js";
+/** Register MCP prompts on the server */
+export function registerPrompts(server) {
+    // === Seasonal Review ===
+    server.addPrompt({
+        name: "seasonal_review",
+        description: "Review this season's anime lineup against my taste profile.",
+        arguments: [
+            {
+                name: "season",
+                description: "Season to review: WINTER, SPRING, SUMMER, or FALL. Defaults to current.",
+                required: false,
+            },
+            {
+                name: "year",
+                description: "Year to review. Defaults to current year.",
+                required: false,
+            },
+        ],
+        async load({ season, year }) {
+            const resolved = resolveSeasonYear(season, year ? Number(year) : undefined);
+            return {
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: `Use anilist_pick with source SEASONAL to review the ${resolved.season} ${resolved.year} anime season against my taste profile. ` +
+                                `Show the top picks and explain why each one matches my preferences.`,
+                        },
+                    },
+                ],
+            };
+        },
+    });
+    // === What To Watch ===
+    server.addPrompt({
+        name: "what_to_watch",
+        description: "Plan what to watch right now from my current list.",
+        arguments: [
+            {
+                name: "mood",
+                description: "Mood filter: dark, chill, hype, action, romantic, funny, brainy, sad, etc.",
+                required: false,
+            },
+            {
+                name: "minutes",
+                description: "Time budget in minutes. Defaults to 90.",
+                required: false,
+            },
+        ],
+        async load({ mood, minutes }) {
+            const budget = minutes ? Number(minutes) : 90;
+            const moodClause = mood ? ` in a ${mood} mood` : "";
+            return {
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: `I have ${budget} minutes${moodClause}. ` +
+                                `Use anilist_session to plan what I should watch from my current list.`,
+                        },
+                    },
+                ],
+            };
+        },
+    });
+    // === Roast My Taste ===
+    server.addPrompt({
+        name: "roast_my_taste",
+        description: "Get a humorous roast of your anime taste.",
+        arguments: [
+            {
+                name: "username",
+                description: "Username to roast. Defaults to configured user.",
+                required: false,
+            },
+        ],
+        async load({ username }) {
+            const target = username ?? "my";
+            const userClause = username
+                ? `Use anilist_taste for ${username}`
+                : "Use anilist_taste for me";
+            return {
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: `${userClause} and then roast ${target} anime taste. ` +
+                                `Be funny and specific about genre preferences and scoring patterns.`,
+                        },
+                    },
+                ],
+            };
+        },
+    });
+    // === Compare Us ===
+    server.addPrompt({
+        name: "compare_us",
+        description: "Compare my taste with another user.",
+        arguments: [
+            {
+                name: "other_username",
+                description: "The other user to compare with.",
+                required: true,
+            },
+        ],
+        async load({ other_username }) {
+            return {
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: `Use anilist_compare to compare my taste with ${other_username}. ` +
+                                `Highlight the biggest taste differences and shared favourites.`,
+                        },
+                    },
+                ],
+            };
+        },
+    });
+    // === Year In Review ===
+    server.addPrompt({
+        name: "year_in_review",
+        description: "Get your anime/manga year in review wrapped summary.",
+        arguments: [
+            {
+                name: "year",
+                description: "Year to review. Defaults to current year.",
+                required: false,
+            },
+        ],
+        async load({ year }) {
+            const y = year ?? new Date().getFullYear().toString();
+            return {
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: `Use anilist_wrapped to generate my ${y} anime and manga year in review. ` +
+                                `Summarize the highlights and interesting patterns.`,
+                        },
+                    },
+                ],
+            };
+        },
+    });
+    // === Explain Title ===
+    server.addPrompt({
+        name: "explain_title",
+        description: "Explain why you would or wouldn't like a specific title.",
+        arguments: [
+            {
+                name: "title",
+                description: "The anime or manga title to explain.",
+                required: true,
+            },
+        ],
+        async load({ title }) {
+            return {
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: `Use anilist_explain to analyze why I would or wouldn't like "${title}". ` +
+                                `Break down genre affinity, theme alignment, and how it compares to titles I've enjoyed.`,
+                        },
+                    },
+                ],
+            };
+        },
+    });
+    // === Find Similar ===
+    server.addPrompt({
+        name: "find_similar",
+        description: "Find titles similar to one you enjoyed.",
+        arguments: [
+            {
+                name: "title",
+                description: "The anime or manga to find similar titles for.",
+                required: true,
+            },
+        ],
+        async load({ title }) {
+            return {
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: `Use anilist_similar to find titles similar to "${title}". ` +
+                                `Explain what makes each recommendation similar and whether it's on my list already.`,
+                        },
+                    },
+                ],
+            };
+        },
+    });
+}

package/dist/resources.d.ts

@@ -0,0 +1,4 @@
+/** MCP Resources: expose user context without tool calls */
+import type { FastMCP } from "fastmcp";
+/** Register MCP resources on the server */
+export declare function registerResources(server: FastMCP): void;

package/dist/resources.js

@@ -0,0 +1,111 @@
+/** MCP Resources: expose user context without tool calls */
+import { anilistClient } from "./api/client.js";
+import { USER_PROFILE_QUERY, USER_STATS_QUERY } from "./api/queries.js";
+import { buildTasteProfile, describeTasteProfile, } from "./engine/taste.js";
+import { formatProfile } from "./tools/social.js";
+import { formatListEntry } from "./tools/lists.js";
+import { getDefaultUsername, detectScoreFormat } from "./utils.js";
+/** Register MCP resources on the server */
+export function registerResources(server) {
+    // === User Profile ===
+    server.addResource({
+        uri: "anilist://profile",
+        name: "User Profile",
+        description: "AniList profile with bio, anime/manga stats, and favourites.",
+        mimeType: "text/plain",
+        async load() {
+            const username = getDefaultUsername();
+            const data = await anilistClient.query(USER_PROFILE_QUERY, { name: username }, { cache: "stats" });
+            return { text: formatProfile(data.User) };
+        },
+    });
+    // === Taste Profile ===
+    server.addResourceTemplate({
+        uriTemplate: "anilist://taste/{type}",
+        name: "Taste Profile",
+        description: "Genre weights, top themes, scoring patterns, and format split derived from completed list.",
+        mimeType: "text/plain",
+        arguments: [
+            {
+                name: "type",
+                description: "ANIME or MANGA",
+                required: true,
+            },
+        ],
+        async load({ type }) {
+            const username = getDefaultUsername();
+            const mediaType = String(type).toUpperCase();
+            const entries = await anilistClient.fetchList(username, mediaType, "COMPLETED");
+            const profile = buildTasteProfile(entries);
+            return { text: formatTasteProfile(profile, username) };
+        },
+    });
+    // === Current List ===
+    server.addResourceTemplate({
+        uriTemplate: "anilist://list/{type}",
+        name: "Current List",
+        description: "Currently watching anime or reading manga entries with progress and scores.",
+        mimeType: "text/plain",
+        arguments: [
+            {
+                name: "type",
+                description: "ANIME or MANGA",
+                required: true,
+            },
+        ],
+        async load({ type }) {
+            const username = getDefaultUsername();
+            const mediaType = String(type).toUpperCase();
+            const [entries, scoreFormat] = await Promise.all([
+                anilistClient.fetchList(username, mediaType, "CURRENT"),
+                detectScoreFormat(async () => {
+                    const data = await anilistClient.query(USER_STATS_QUERY, { name: username }, { cache: "stats" });
+                    return data.User.mediaListOptions.scoreFormat;
+                }),
+            ]);
+            if (!entries.length) {
+                return {
+                    text: `${username} has no current ${mediaType.toLowerCase()} entries.`,
+                };
+            }
+            const header = `${username}'s current ${mediaType.toLowerCase()} - ${entries.length} entries`;
+            const formatted = entries.map((entry, i) => formatListEntry(entry, i + 1, scoreFormat));
+            return { text: [header, "", ...formatted].join("\n\n") };
+        },
+    });
+}
+// === Formatting Helpers ===
+/** Format a taste profile with detailed breakdowns */
+function formatTasteProfile(profile, username) {
+    const lines = [
+        `# Taste Profile: ${username}`,
+        "",
+        describeTasteProfile(profile, username),
+    ];
+    // Detailed genre breakdown
+    if (profile.genres.length > 0) {
+        lines.push("", "Genre Weights (higher = stronger preference):");
+        for (const g of profile.genres.slice(0, 10)) {
+            lines.push(`  ${g.name}: ${g.weight.toFixed(2)} (${g.count} titles)`);
+        }
+    }
+    // Detailed tag breakdown
+    if (profile.tags.length > 0) {
+        lines.push("", "Top Themes:");
+        for (const t of profile.tags.slice(0, 10)) {
+            lines.push(`  ${t.name}: ${t.weight.toFixed(2)} (${t.count} titles)`);
+        }
+    }
+    // Score distribution
+    if (profile.scoring.totalScored > 0) {
+        lines.push("", "Score Distribution:");
+        for (let s = 10; s >= 1; s--) {
+            const count = profile.scoring.distribution[s] ?? 0;
+            if (count > 0) {
+                const bar = "#".repeat(Math.min(count, 30));
+                lines.push(`  ${s}/10: ${bar} (${count})`);
+            }
+        }
+    }
+    return lines.join("\n");
+}

package/dist/tools/lists.d.ts

@@ -1,4 +1,7 @@
 /** User list tools: fetch and display a user's anime/manga list. */
 import type { FastMCP } from "fastmcp";
+import type { AniListMediaListEntry, ScoreFormat } from "../types.js";
 /** Register user list tools on the MCP server */
 export declare function registerListTools(server: FastMCP): void;
+/** Format a single list entry with title, progress, score, and update date */
+export declare function formatListEntry(entry: AniListMediaListEntry, index: number, scoreFmt: ScoreFormat): string;

package/dist/tools/lists.js

@@ -207,7 +207,7 @@ function formatTypeStats(stats, label) {
     return lines;
 }
 /** Format a single list entry with title, progress, score, and update date */
-function formatListEntry(entry, index, scoreFmt) {
+export function formatListEntry(entry, index, scoreFmt) {
     const media = entry.media;
     const title = getTitle(media.title);
     const format = media.format ?? "?";

package/dist/tools/social.d.ts

@@ -1,4 +1,7 @@
 /** Social tools: activity feed, user profiles, and community reviews. */
 import type { FastMCP } from "fastmcp";
+import type { UserProfileResponse } from "../types.js";
 /** Register social and community tools */
 export declare function registerSocialTools(server: FastMCP): void;
+/** Format a user profile as text */
+export declare function formatProfile(user: UserProfileResponse["User"]): string;

package/dist/tools/social.js

@@ -62,49 +62,7 @@ export function registerSocialTools(server) {
             try {
                 const username = getDefaultUsername(args.username);
                 const data = await anilistClient.query(USER_PROFILE_QUERY, { name: username }, { cache: "stats" });
-                const user = data.User;
-                const lines = [`# ${user.name}`, user.siteUrl, ""];
-                // About/bio
-                if (user.about) {
-                    lines.push(truncateDescription(user.about, 500), "");
-                }
-                // Anime stats
-                const a = user.statistics.anime;
-                if (a.count > 0) {
-                    const days = (a.minutesWatched / 1440).toFixed(1);
-                    lines.push(`## Anime: ${a.count} titles | ${a.episodesWatched} episodes | ${days} days | Mean ${a.meanScore.toFixed(1)}`);
-                }
-                // Manga stats
-                const m = user.statistics.manga;
-                if (m.count > 0) {
-                    lines.push(`## Manga: ${m.count} titles | ${m.chaptersRead} chapters | ${m.volumesRead} volumes | Mean ${m.meanScore.toFixed(1)}`);
-                }
-                // Favorites
-                const fav = user.favourites;
-                if (fav.anime.nodes.length) {
-                    lines.push("", "Favourite Anime: " +
-                        fav.anime.nodes.map((n) => getTitle(n.title)).join(", "));
-                }
-                if (fav.manga.nodes.length) {
-                    lines.push("Favourite Manga: " +
-                        fav.manga.nodes.map((n) => getTitle(n.title)).join(", "));
-                }
-                if (fav.characters.nodes.length) {
-                    lines.push("Favourite Characters: " +
-                        fav.characters.nodes.map((n) => n.name.full).join(", "));
-                }
-                if (fav.staff.nodes.length) {
-                    lines.push("Favourite Staff: " +
-                        fav.staff.nodes.map((n) => n.name.full).join(", "));
-                }
-                if (fav.studios.nodes.length) {
-                    lines.push("Favourite Studios: " +
-                        fav.studios.nodes.map((n) => n.name).join(", "));
-                }
-                // Account age
-                const created = new Date(user.createdAt * 1000).toLocaleDateString("en-US", { month: "short", year: "numeric" });
-                lines.push("", `Member since ${created}`);
-                return lines.join("\n");
+                return formatProfile(data.User);
             }
             catch (error) {
                 return throwToolError(error, "fetching profile");
@@ -178,6 +136,51 @@ export function registerSocialTools(server) {
     });
 }
 // === Formatting Helpers ===
+/** Format a user profile as text */
+export function formatProfile(user) {
+    const lines = [`# ${user.name}`, user.siteUrl, ""];
+    // About/bio
+    if (user.about) {
+        lines.push(truncateDescription(user.about, 500), "");
+    }
+    // Anime stats
+    const a = user.statistics.anime;
+    if (a.count > 0) {
+        const days = (a.minutesWatched / 1440).toFixed(1);
+        lines.push(`## Anime: ${a.count} titles | ${a.episodesWatched} episodes | ${days} days | Mean ${a.meanScore.toFixed(1)}`);
+    }
+    // Manga stats
+    const m = user.statistics.manga;
+    if (m.count > 0) {
+        lines.push(`## Manga: ${m.count} titles | ${m.chaptersRead} chapters | ${m.volumesRead} volumes | Mean ${m.meanScore.toFixed(1)}`);
+    }
+    // Favourites
+    const fav = user.favourites;
+    if (fav.anime.nodes.length) {
+        lines.push("", "Favourite Anime: " +
+            fav.anime.nodes.map((n) => getTitle(n.title)).join(", "));
+    }
+    if (fav.manga.nodes.length) {
+        lines.push("Favourite Manga: " +
+            fav.manga.nodes.map((n) => getTitle(n.title)).join(", "));
+    }
+    if (fav.characters.nodes.length) {
+        lines.push("Favourite Characters: " +
+            fav.characters.nodes.map((n) => n.name.full).join(", "));
+    }
+    if (fav.staff.nodes.length) {
+        lines.push("Favourite Staff: " +
+            fav.staff.nodes.map((n) => n.name.full).join(", "));
+    }
+    if (fav.studios.nodes.length) {
+        lines.push("Favourite Studios: " +
+            fav.studios.nodes.map((n) => n.name).join(", "));
+    }
+    // Account age
+    const created = new Date(user.createdAt * 1000).toLocaleDateString("en-US", { month: "short", year: "numeric" });
+    lines.push("", `Member since ${created}`);
+    return lines.join("\n");
+}
 /** Format a single activity entry */
 function formatActivity(activity, index) {
     const date = new Date(activity.createdAt * 1000).toLocaleDateString("en-US", {

package/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": "0.3",
   "name": "ani-mcp",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "display_name": "AniList MCP",
   "description": "A smart MCP server for AniList that gets your anime/manga taste - not just API calls.",
   "author": {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ani-mcp",
   "mcpName": "io.github.gavxm/ani-mcp",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "A smart [MCP](https://modelcontextprotocol.io) server for [AniList](https://anilist.co) that gets your anime/manga taste - not just API calls.",
   "type": "module",
   "main": "dist/index.js",

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/gavxm/ani-mcp",
     "source": "github"
   },
-  "version": "0.5.1",
+  "version": "0.6.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "ani-mcp",
-      "version": "0.5.1",
+      "version": "0.6.0",
       "transport": {
         "type": "stdio"
       },