ani-mcp 0.7.0 → 0.8.0

package/README.md

@@ -117,6 +117,17 @@ Works with any MCP-compatible client.
 | `anilist_favourite` | Toggle favourite on anime, manga, character, staff, or studio |
 | `anilist_activity` | Post a text activity to your feed |
 
+### Analytics
+
+| Tool | Description |
+| --- | --- |
+| `anilist_calibration` | Per-genre scoring bias vs community consensus |
+| `anilist_drops` | Drop pattern analysis - genre/tag clusters and median drop point |
+| `anilist_evolution` | How your taste shifted across 2-year time windows |
+| `anilist_completionist` | Franchise completion tracking via relation graph |
+| `anilist_seasonal_stats` | Per-season pick/finish/drop rates |
+| `anilist_pace` | Estimated completion date for currently watching titles |
+
 ### Write (requires `ANILIST_TOKEN`)
 
 | Tool | Description |
@@ -125,6 +136,9 @@ Works with any MCP-compatible client.
 | `anilist_add_to_list` | Add a title to your list with a status |
 | `anilist_rate` | Score a title (0-10) |
 | `anilist_delete_from_list` | Remove an entry from your list |
+| `anilist_undo` | Undo the last write operation |
+| `anilist_unscored` | List completed but unscored titles for batch scoring |
+| `anilist_batch_update` | Bulk filter + action on list entries (dry-run default) |
 
 ## Resources
 

package/dist/api/queries.d.ts

@@ -28,6 +28,8 @@ export declare const AIRING_SCHEDULE_QUERY = "\n  query AiringSchedule($id: Int,
 export declare const CHARACTER_SEARCH_QUERY = "\n  query CharacterSearch($search: String!, $page: Int, $perPage: Int) {\n    Page(page: $page, perPage: $perPage) {\n      pageInfo { total hasNextPage }\n      characters(search: $search, sort: FAVOURITES_DESC) {\n        id\n        name { full native alternative }\n        image { medium }\n        favourites\n        siteUrl\n        media(sort: POPULARITY_DESC, perPage: 5) {\n          edges {\n            characterRole\n            node {\n              id\n              title { romaji english }\n              format\n              type\n              siteUrl\n            }\n            voiceActors(language: JAPANESE) {\n              id\n              name { full }\n              siteUrl\n            }\n          }\n        }\n      }\n    }\n  }\n";
 /** Create or update a list entry */
 export declare const SAVE_MEDIA_LIST_ENTRY_MUTATION = "\n  mutation SaveMediaListEntry(\n    $mediaId: Int\n    $status: MediaListStatus\n    $scoreRaw: Int\n    $progress: Int\n    $notes: String\n    $private: Boolean\n  ) {\n    SaveMediaListEntry(\n      mediaId: $mediaId\n      status: $status\n      scoreRaw: $scoreRaw\n      progress: $progress\n      notes: $notes\n      private: $private\n    ) {\n      id\n      mediaId\n      status\n      score(format: POINT_10)\n      progress\n    }\n  }\n";
+/** Fetch a single list entry for snapshotting before mutations */
+export declare const MEDIA_LIST_ENTRY_QUERY = "\n  query MediaListEntry($id: Int, $mediaId: Int, $userName: String) {\n    MediaList(id: $id, mediaId: $mediaId, userName: $userName) {\n      id\n      mediaId\n      status\n      score(format: POINT_10)\n      progress\n      notes\n      private\n    }\n  }\n";
 /** Remove a list entry */
 export declare const DELETE_MEDIA_LIST_ENTRY_MUTATION = "\n  mutation DeleteMediaListEntry($id: Int!) {\n    DeleteMediaListEntry(id: $id) {\n      deleted\n    }\n  }\n";
 /** User's anime/manga list, grouped by status. Omit $status to get all lists. */

package/dist/api/queries.js

@@ -394,6 +394,20 @@ export const SAVE_MEDIA_LIST_ENTRY_MUTATION = `
     }
   }
 `;
+/** Fetch a single list entry for snapshotting before mutations */
+export const MEDIA_LIST_ENTRY_QUERY = `
+  query MediaListEntry($id: Int, $mediaId: Int, $userName: String) {
+    MediaList(id: $id, mediaId: $mediaId, userName: $userName) {
+      id
+      mediaId
+      status
+      score(format: POINT_10)
+      progress
+      notes
+      private
+    }
+  }
+`;
 /** Remove a list entry */
 export const DELETE_MEDIA_LIST_ENTRY_MUTATION = `
   mutation DeleteMediaListEntry($id: Int!) {

package/dist/engine/profile-cache.d.ts

@@ -0,0 +1,13 @@
+/** Cached taste profiles with hash-based invalidation. */
+import type { TasteProfile } from "./taste.js";
+import type { AniListMediaListEntry } from "../types.js";
+/** Stable hash of entry IDs and scores to detect list changes */
+export declare function computeListHash(entries: AniListMediaListEntry[]): string;
+/** Get a cached profile if the list hash matches */
+export declare function getCachedProfile(key: string, listHash: string): TasteProfile | undefined;
+/** Store a profile in the cache */
+export declare function setCachedProfile(key: string, profile: TasteProfile, listHash: string): void;
+/** Invalidate all profiles for a username */
+export declare function invalidateUserProfiles(username: string): void;
+/** Clear all cached profiles */
+export declare function clearProfileCache(): void;

package/dist/engine/profile-cache.js

@@ -0,0 +1,36 @@
+/** Cached taste profiles with hash-based invalidation. */
+import { LRUCache } from "lru-cache";
+// 30-minute TTL, max 20 profiles
+const cache = new LRUCache({
+    max: 20,
+    ttl: 30 * 60 * 1000,
+});
+/** Stable hash of entry IDs and scores to detect list changes */
+export function computeListHash(entries) {
+    const pairs = entries.map((e) => `${e.id}:${e.score}`).sort();
+    return pairs.join(",");
+}
+/** Get a cached profile if the list hash matches */
+export function getCachedProfile(key, listHash) {
+    const cached = cache.get(key);
+    if (cached && cached.listHash === listHash)
+        return cached.profile;
+    return undefined;
+}
+/** Store a profile in the cache */
+export function setCachedProfile(key, profile, listHash) {
+    cache.set(key, { profile, listHash });
+}
+/** Invalidate all profiles for a username */
+export function invalidateUserProfiles(username) {
+    const lower = username.toLowerCase();
+    for (const key of cache.keys()) {
+        if (key.toLowerCase().startsWith(`${lower}::`)) {
+            cache.delete(key);
+        }
+    }
+}
+/** Clear all cached profiles */
+export function clearProfileCache() {
+    cache.clear();
+}

package/dist/engine/undo.d.ts

@@ -0,0 +1,42 @@
+/** Session-scoped undo stack for write operations. */
+export interface EntrySnapshot {
+    id: number;
+    mediaId: number;
+    status: string;
+    score: number;
+    progress: number;
+    notes: string | null;
+    private: boolean;
+}
+export type UndoOperation = {
+    type: "update";
+    before: EntrySnapshot;
+} | {
+    type: "create";
+    entryId: number;
+    mediaId: number;
+} | {
+    type: "delete";
+    before: EntrySnapshot;
+} | {
+    type: "batch";
+    entries: Array<{
+        before: EntrySnapshot;
+    }>;
+};
+export interface UndoRecord {
+    operation: UndoOperation;
+    toolName: string;
+    timestamp: number;
+    description: string;
+}
+/** Push a record onto the undo stack, trimming oldest if full */
+export declare function pushUndo(record: UndoRecord): void;
+/** Pop the most recent undo record */
+export declare function popUndo(): UndoRecord | undefined;
+/** Inspect the most recent record without removing */
+export declare function peekUndo(): UndoRecord | undefined;
+/** Current stack depth */
+export declare function undoStackSize(): number;
+/** Clear all undo records */
+export declare function clearUndoStack(): void;

package/dist/engine/undo.js

@@ -0,0 +1,26 @@
+/** Session-scoped undo stack for write operations. */
+// === Stack ===
+const MAX_UNDO = 20;
+const stack = [];
+/** Push a record onto the undo stack, trimming oldest if full */
+export function pushUndo(record) {
+    stack.push(record);
+    while (stack.length > MAX_UNDO)
+        stack.shift();
+}
+/** Pop the most recent undo record */
+export function popUndo() {
+    return stack.pop();
+}
+/** Inspect the most recent record without removing */
+export function peekUndo() {
+    return stack.length > 0 ? stack[stack.length - 1] : undefined;
+}
+/** Current stack depth */
+export function undoStackSize() {
+    return stack.length;
+}
+/** Clear all undo records */
+export function clearUndoStack() {
+    stack.length = 0;
+}

package/dist/index.js

@@ -21,7 +21,7 @@ if (!process.env.ANILIST_TOKEN) {
 }
 const server = new FastMCP({
     name: "ani-mcp",
-    version: "0.7.0",
+    version: "0.8.0",
 });
 registerSearchTools(server);
 registerListTools(server);

package/dist/schemas.d.ts

@@ -92,6 +92,7 @@ export declare const PickInputSchema: z.ZodObject<{
     year: z.ZodOptional<z.ZodNumber>;
     mood: z.ZodOptional<z.ZodString>;
     maxEpisodes: z.ZodOptional<z.ZodNumber>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
     limit: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type PickInput = z.infer<typeof PickInputSchema>;
@@ -423,3 +424,50 @@ export declare const PaceInputSchema: z.ZodObject<{
     }>>;
 }, z.core.$strip>;
 export type PaceInput = z.infer<typeof PaceInputSchema>;
+/** Input for undoing the last write operation */
+export declare const UndoInputSchema: z.ZodObject<{}, z.core.$strip>;
+export type UndoInput = z.infer<typeof UndoInputSchema>;
+/** Input for listing unscored completed titles */
+export declare const UnscoredInputSchema: z.ZodObject<{
+    username: z.ZodOptional<z.ZodString>;
+    type: z.ZodDefault<z.ZodEnum<{
+        ANIME: "ANIME";
+        MANGA: "MANGA";
+    }>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type UnscoredInput = z.infer<typeof UnscoredInputSchema>;
+/** Input for batch-updating multiple list entries */
+export declare const BatchUpdateInputSchema: z.ZodObject<{
+    username: z.ZodOptional<z.ZodString>;
+    type: z.ZodDefault<z.ZodEnum<{
+        ANIME: "ANIME";
+        MANGA: "MANGA";
+    }>>;
+    filter: z.ZodObject<{
+        status: z.ZodOptional<z.ZodEnum<{
+            CURRENT: "CURRENT";
+            COMPLETED: "COMPLETED";
+            PLANNING: "PLANNING";
+            DROPPED: "DROPPED";
+            PAUSED: "PAUSED";
+        }>>;
+        scoreBelow: z.ZodOptional<z.ZodNumber>;
+        scoreAbove: z.ZodOptional<z.ZodNumber>;
+        unscored: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    action: z.ZodObject<{
+        setStatus: z.ZodOptional<z.ZodEnum<{
+            CURRENT: "CURRENT";
+            COMPLETED: "COMPLETED";
+            PLANNING: "PLANNING";
+            DROPPED: "DROPPED";
+            PAUSED: "PAUSED";
+            REPEATING: "REPEATING";
+        }>>;
+        setScore: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    dryRun: z.ZodDefault<z.ZodBoolean>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type BatchUpdateInput = z.infer<typeof BatchUpdateInputSchema>;

package/dist/schemas.js

@@ -166,6 +166,11 @@ export const PickInputSchema = z.object({
         .positive()
         .optional()
         .describe("Filter out series longer than this episode count"),
+    exclude: z
+        .array(z.number().int().positive())
+        .max(50)
+        .optional()
+        .describe("Media IDs to exclude from results (e.g. from previous recommendations)"),
     limit: z
         .number()
         .int()
@@ -704,3 +709,85 @@ export const PaceInputSchema = z.object({
         .default("ANIME")
         .describe("Estimate pace for anime or manga"),
 });
+// === 0.8.0 Persistent Intelligence ===
+/** Input for undoing the last write operation */
+export const UndoInputSchema = z.object({});
+/** Input for listing unscored completed titles */
+export const UnscoredInputSchema = z.object({
+    username: usernameSchema
+        .optional()
+        .describe("AniList username. Falls back to configured default if not provided."),
+    type: z
+        .enum(["ANIME", "MANGA"])
+        .default("ANIME")
+        .describe("Check anime or manga list for unscored titles"),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .default(20)
+        .describe("Number of unscored titles to return (default 20, max 50)"),
+});
+/** Input for batch-updating multiple list entries */
+export const BatchUpdateInputSchema = z.object({
+    username: usernameSchema
+        .optional()
+        .describe("AniList username. Falls back to configured default if not provided."),
+    type: z
+        .enum(["ANIME", "MANGA"])
+        .default("ANIME")
+        .describe("Update anime or manga entries"),
+    filter: z.object({
+        status: z
+            .enum(["CURRENT", "COMPLETED", "PLANNING", "DROPPED", "PAUSED"])
+            .optional()
+            .describe("Only match entries with this status"),
+        scoreBelow: z
+            .number()
+            .min(0)
+            .max(10)
+            .optional()
+            .describe("Only match entries scored below this value"),
+        scoreAbove: z
+            .number()
+            .min(0)
+            .max(10)
+            .optional()
+            .describe("Only match entries scored above this value"),
+        unscored: z
+            .boolean()
+            .optional()
+            .describe("Only match entries with no score"),
+    }),
+    action: z.object({
+        setStatus: z
+            .enum([
+            "CURRENT",
+            "PLANNING",
+            "COMPLETED",
+            "DROPPED",
+            "PAUSED",
+            "REPEATING",
+        ])
+            .optional()
+            .describe("Change status to this value"),
+        setScore: z
+            .number()
+            .min(0)
+            .max(10)
+            .optional()
+            .describe("Set score to this value (0 removes score)"),
+    }),
+    dryRun: z
+        .boolean()
+        .default(true)
+        .describe("Preview changes without applying them. Set to false to execute."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .default(50)
+        .describe("Max entries to update in one call (default 50, max 100)"),
+});

package/dist/tools/recommend.js

@@ -9,6 +9,7 @@ import { parseMood, hasMoodMatch, seasonalMoodSuggestions, } from "../engine/moo
 import { computeCompatibility, computeGenreDivergences, findCrossRecs, } from "../engine/compare.js";
 import { rankSimilar } from "../engine/similar.js";
 import { buildWatchOrder } from "../engine/franchise.js";
+import { computeListHash, getCachedProfile, setCachedProfile, } from "../engine/profile-cache.js";
 // User scores are normalized to 1-10 via score(format: POINT_10) in the list query.
 // Community meanScore is 0-100. Multiply user score by 10 to compare on the same scale.
 const USER_SCORE_SCALE = 10;
@@ -29,18 +30,29 @@ async function discoverByTaste(profile, type, completedIds) {
     }, { cache: "search" });
     return data.Page.media.filter((m) => !completedIds.has(m.id));
 }
-/** Build a taste profile for a username, optionally merging anime and manga */
+/** Build a taste profile for a username, with LRU caching */
 async function profileForUser(username, type) {
+    let entries;
     if (type === "BOTH") {
         const [anime, manga] = await Promise.all([
             anilistClient.fetchList(username, "ANIME", "COMPLETED"),
             anilistClient.fetchList(username, "MANGA", "COMPLETED"),
         ]);
-        const all = [...anime, ...manga];
-        return { profile: buildTasteProfile(all), entries: all };
+        entries = [...anime, ...manga];
     }
-    const entries = await anilistClient.fetchList(username, type, "COMPLETED");
-    return { profile: buildTasteProfile(entries), entries };
+    else {
+        entries = await anilistClient.fetchList(username, type, "COMPLETED");
+    }
+    // Check profile cache
+    const cacheKey = `${username}::${type}`;
+    const hash = computeListHash(entries);
+    const cached = getCachedProfile(cacheKey, hash);
+    if (cached)
+        return { profile: cached, entries };
+    // Rebuild and cache
+    const profile = buildTasteProfile(entries);
+    setCachedProfile(cacheKey, profile, hash);
+    return { profile, entries };
 }
 // === Tool Registration ===
 /** Register smart tools on the MCP server */
@@ -195,6 +207,11 @@ export function registerRecommendTools(server) {
                 if (maxEps) {
                     candidates = candidates.filter((m) => !m.episodes || m.episodes <= maxEps);
                 }
+                // Exclude previously shown IDs
+                if (args.exclude?.length) {
+                    const excludeSet = new Set(args.exclude);
+                    candidates = candidates.filter((m) => !excludeSet.has(m.id));
+                }
                 if (candidates.length === 0) {
                     return fromDiscovery
                         ? `Could not find titles matching ${username}'s taste. Try a different mood or type.`

package/dist/tools/write.d.ts

@@ -1,4 +1,4 @@
-/** Write tools: list mutations, favourites, and activity posting. */
+/** Write tools: list mutations, favourites, activity, undo, batch, and unscored. */
 import type { FastMCP } from "fastmcp";
 /** Register list mutation tools */
 export declare function registerWriteTools(server: FastMCP): void;

package/dist/tools/write.js

@@ -1,8 +1,10 @@
-/** Write tools: list mutations, favourites, and activity posting. */
+/** Write tools: list mutations, favourites, activity, undo, batch, and unscored. */
 import { anilistClient } from "../api/client.js";
-import { SAVE_MEDIA_LIST_ENTRY_MUTATION, DELETE_MEDIA_LIST_ENTRY_MUTATION, TOGGLE_FAVOURITE_MUTATION, SAVE_TEXT_ACTIVITY_MUTATION, VIEWER_QUERY, } from "../api/queries.js";
-import { UpdateProgressInputSchema, AddToListInputSchema, RateInputSchema, DeleteFromListInputSchema, FavouriteInputSchema, PostActivityInputSchema, } from "../schemas.js";
-import { throwToolError, formatScore, detectScoreFormat } from "../utils.js";
+import { SAVE_MEDIA_LIST_ENTRY_MUTATION, DELETE_MEDIA_LIST_ENTRY_MUTATION, TOGGLE_FAVOURITE_MUTATION, SAVE_TEXT_ACTIVITY_MUTATION, VIEWER_QUERY, MEDIA_LIST_ENTRY_QUERY, } from "../api/queries.js";
+import { pushUndo, popUndo } from "../engine/undo.js";
+import { invalidateUserProfiles } from "../engine/profile-cache.js";
+import { UpdateProgressInputSchema, AddToListInputSchema, RateInputSchema, DeleteFromListInputSchema, FavouriteInputSchema, PostActivityInputSchema, UndoInputSchema, UnscoredInputSchema, BatchUpdateInputSchema, } from "../schemas.js";
+import { throwToolError, formatScore, detectScoreFormat, getTitle, getDefaultUsername, } from "../utils.js";
 // === Auth Guard ===
 /** Guard against unauthenticated write attempts */
 function requireAuth() {
@@ -10,6 +12,34 @@ function requireAuth() {
         throw new Error("ANILIST_TOKEN is not set. Write operations require an authenticated AniList account.");
     }
 }
+// === Undo Helpers ===
+/** Get the authenticated user's username */
+async function getViewerName() {
+    const data = await anilistClient.query(VIEWER_QUERY, {}, { cache: "stats" });
+    return data.Viewer.name;
+}
+/** Snapshot a list entry before mutation */
+async function snapshotByMediaId(mediaId) {
+    const userName = await getViewerName();
+    const data = await anilistClient.query(MEDIA_LIST_ENTRY_QUERY, { mediaId, userName }, { cache: null });
+    return data.MediaList ?? null;
+}
+/** Snapshot a list entry by its entry ID */
+async function snapshotByEntryId(entryId) {
+    const data = await anilistClient.query(MEDIA_LIST_ENTRY_QUERY, { id: entryId }, { cache: null });
+    return data.MediaList ?? null;
+}
+/** Format an undo hint for output */
+function undoHint(before) {
+    if (!before)
+        return '(New entry - say "undo" to remove)';
+    const parts = [before.status];
+    if (before.progress > 0)
+        parts.push(`progress ${before.progress}`);
+    if (before.score > 0)
+        parts.push(`score ${before.score}`);
+    return `(Previous: ${parts.join(", ")} - say "undo" to revert)`;
+}
 // === Tool Registration ===
 /** Register list mutation tools */
 export function registerWriteTools(server) {
@@ -31,6 +61,8 @@ export function registerWriteTools(server) {
         execute: async (args) => {
             try {
                 requireAuth();
+                // Snapshot before mutation
+                const before = await snapshotByMediaId(args.mediaId);
                 const variables = {
                     mediaId: args.mediaId,
                     progress: args.progress,
@@ -38,12 +70,23 @@ export function registerWriteTools(server) {
                 };
                 const data = await anilistClient.query(SAVE_MEDIA_LIST_ENTRY_MUTATION, variables, { cache: null });
                 anilistClient.clearCache();
+                invalidateUserProfiles(await getViewerName());
                 const entry = data.SaveMediaListEntry;
+                // Track for undo
+                pushUndo({
+                    operation: before
+                        ? { type: "update", before }
+                        : { type: "create", entryId: entry.id, mediaId: args.mediaId },
+                    toolName: "anilist_update_progress",
+                    timestamp: Date.now(),
+                    description: `Set progress to ${args.progress} on media ${args.mediaId}`,
+                });
                 return [
                     `Progress updated.`,
                     `Status: ${entry.status}`,
                     `Progress: ${entry.progress}`,
                     `Entry ID: ${entry.id}`,
+                    undoHint(before),
                 ].join("\n");
             }
             catch (error) {
@@ -69,6 +112,8 @@ export function registerWriteTools(server) {
         execute: async (args) => {
             try {
                 requireAuth();
+                // Snapshot before mutation
+                const before = await snapshotByMediaId(args.mediaId);
                 const variables = {
                     mediaId: args.mediaId,
                     status: args.status,
@@ -83,7 +128,17 @@ export function registerWriteTools(server) {
                     }),
                 ]);
                 anilistClient.clearCache();
+                invalidateUserProfiles(await getViewerName());
                 const entry = data.SaveMediaListEntry;
+                // Track for undo
+                pushUndo({
+                    operation: before
+                        ? { type: "update", before }
+                        : { type: "create", entryId: entry.id, mediaId: args.mediaId },
+                    toolName: "anilist_add_to_list",
+                    timestamp: Date.now(),
+                    description: `Set status to ${args.status} on media ${args.mediaId}`,
+                });
                 const scoreStr = entry.score > 0
                     ? ` | Score: ${formatScore(entry.score, scoreFmt)}`
                     : "";
@@ -91,6 +146,7 @@ export function registerWriteTools(server) {
                     `Added to list.`,
                     `Status: ${entry.status}${scoreStr}`,
                     `Entry ID: ${entry.id}`,
+                    undoHint(before),
                 ].join("\n");
             }
             catch (error) {
@@ -115,6 +171,8 @@ export function registerWriteTools(server) {
         execute: async (args) => {
             try {
                 requireAuth();
+                // Snapshot before mutation
+                const before = await snapshotByMediaId(args.mediaId);
                 const [data, scoreFmt] = await Promise.all([
                     anilistClient.query(SAVE_MEDIA_LIST_ENTRY_MUTATION, { mediaId: args.mediaId, scoreRaw: Math.round(args.score * 10) }, { cache: null }),
                     detectScoreFormat(async () => {
@@ -123,11 +181,24 @@ export function registerWriteTools(server) {
                     }),
                 ]);
                 anilistClient.clearCache();
+                invalidateUserProfiles(await getViewerName());
                 const entry = data.SaveMediaListEntry;
+                // Track for undo
+                if (before) {
+                    pushUndo({
+                        operation: { type: "update", before },
+                        toolName: "anilist_rate",
+                        timestamp: Date.now(),
+                        description: `Set score to ${args.score} on media ${args.mediaId}`,
+                    });
+                }
                 const scoreDisplay = args.score === 0
                     ? "Score removed."
                     : `Score set to ${formatScore(entry.score, scoreFmt)}.`;
-                return [scoreDisplay, `Entry ID: ${entry.id}`].join("\n");
+                const lines = [scoreDisplay, `Entry ID: ${entry.id}`];
+                if (before)
+                    lines.push(undoHint(before));
+                return lines.join("\n");
             }
             catch (error) {
                 return throwToolError(error, "rating");
@@ -151,17 +222,113 @@ export function registerWriteTools(server) {
         execute: async (args) => {
             try {
                 requireAuth();
+                // Snapshot before deletion
+                const before = await snapshotByEntryId(args.entryId);
                 const data = await anilistClient.query(DELETE_MEDIA_LIST_ENTRY_MUTATION, { id: args.entryId }, { cache: null });
                 anilistClient.clearCache();
-                return data.DeleteMediaListEntry.deleted
-                    ? `Entry ${args.entryId} deleted from your list.`
-                    : `Entry ${args.entryId} was not found or already removed.`;
+                invalidateUserProfiles(await getViewerName());
+                if (!data.DeleteMediaListEntry.deleted) {
+                    return `Entry ${args.entryId} was not found or already removed.`;
+                }
+                // Track for undo
+                if (before) {
+                    pushUndo({
+                        operation: { type: "delete", before },
+                        toolName: "anilist_delete_from_list",
+                        timestamp: Date.now(),
+                        description: `Deleted entry ${args.entryId} (media ${before.mediaId})`,
+                    });
+                }
+                const hint = before
+                    ? `\n(Deleted ${before.status} entry - say "undo" to restore)`
+                    : "";
+                return `Entry ${args.entryId} deleted from your list.${hint}`;
             }
             catch (error) {
                 return throwToolError(error, "deleting from list");
             }
         },
     });
+    // === Undo ===
+    server.addTool({
+        name: "anilist_undo",
+        description: "Undo the last write operation (update progress, add to list, rate, delete, or batch update). " +
+            "Restores the previous state of the affected list entry. " +
+            "Requires ANILIST_TOKEN.",
+        parameters: UndoInputSchema,
+        annotations: {
+            title: "Undo",
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+        execute: async () => {
+            try {
+                requireAuth();
+                const record = popUndo();
+                if (!record)
+                    return "Nothing to undo.";
+                const op = record.operation;
+                if (op.type === "update") {
+                    // Restore previous entry state
+                    await anilistClient.query(SAVE_MEDIA_LIST_ENTRY_MUTATION, {
+                        mediaId: op.before.mediaId,
+                        status: op.before.status,
+                        scoreRaw: op.before.score * 10,
+                        progress: op.before.progress,
+                    }, { cache: null });
+                    anilistClient.clearCache();
+                    invalidateUserProfiles(await getViewerName());
+                    return `Undone: restored media ${op.before.mediaId} to ${op.before.status}, progress ${op.before.progress}, score ${op.before.score}.`;
+                }
+                if (op.type === "create") {
+                    // Delete the newly created entry
+                    await anilistClient.query(DELETE_MEDIA_LIST_ENTRY_MUTATION, { id: op.entryId }, { cache: null });
+                    anilistClient.clearCache();
+                    invalidateUserProfiles(await getViewerName());
+                    return `Undone: removed media ${op.mediaId} from your list.`;
+                }
+                if (op.type === "delete") {
+                    // Re-create the deleted entry
+                    await anilistClient.query(SAVE_MEDIA_LIST_ENTRY_MUTATION, {
+                        mediaId: op.before.mediaId,
+                        status: op.before.status,
+                        scoreRaw: op.before.score * 10,
+                        progress: op.before.progress,
+                    }, { cache: null });
+                    anilistClient.clearCache();
+                    invalidateUserProfiles(await getViewerName());
+                    return `Undone: restored media ${op.before.mediaId} to ${op.before.status}, progress ${op.before.progress}.`;
+                }
+                if (op.type === "batch") {
+                    // Restore all entries in the batch
+                    let restored = 0;
+                    for (const item of op.entries) {
+                        try {
+                            await anilistClient.query(SAVE_MEDIA_LIST_ENTRY_MUTATION, {
+                                mediaId: item.before.mediaId,
+                                status: item.before.status,
+                                scoreRaw: item.before.score * 10,
+                                progress: item.before.progress,
+                            }, { cache: null });
+                            restored++;
+                        }
+                        catch {
+                            // Continue on individual failures
+                        }
+                    }
+                    anilistClient.clearCache();
+                    invalidateUserProfiles(await getViewerName());
+                    return `Undone: restored ${restored}/${op.entries.length} entries to their previous state.`;
+                }
+                return "Unknown undo operation type.";
+            }
+            catch (error) {
+                return throwToolError(error, "undoing operation");
+            }
+        },
+    });
     // === Toggle Favourite ===
     // Map entity type to mutation variable name
     const FAVOURITE_VAR_MAP = {
@@ -244,4 +411,182 @@ export function registerWriteTools(server) {
             }
         },
     });
+    // === Unscored Listing ===
+    server.addTool({
+        name: "anilist_unscored",
+        description: "List completed anime or manga that haven't been scored yet. " +
+            "Use when the user wants to catch up on scoring, find unrated titles, " +
+            "or do a batch scoring session. Returns titles sorted by most recently completed.",
+        parameters: UnscoredInputSchema,
+        annotations: {
+            title: "Unscored Titles",
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+        execute: async (args) => {
+            try {
+                const username = getDefaultUsername(args.username);
+                const entries = await anilistClient.fetchList(username, args.type, "COMPLETED");
+                // Filter to unscored, sort by most recently completed
+                const unscored = entries
+                    .filter((e) => e.score === 0)
+                    .sort((a, b) => b.updatedAt - a.updatedAt)
+                    .slice(0, args.limit);
+                if (unscored.length === 0) {
+                    const total = entries.length;
+                    return `All ${total} completed ${args.type.toLowerCase()} titles are scored.`;
+                }
+                const totalUnscored = entries.filter((e) => e.score === 0).length;
+                const lines = [
+                    `# Unscored ${args.type.toLowerCase()} for ${username}`,
+                    "",
+                    `${totalUnscored} completed but unscored (showing ${unscored.length}).`,
+                    "",
+                ];
+                for (const e of unscored) {
+                    const title = getTitle(e.media.title);
+                    const format = e.media.format ?? "?";
+                    const community = e.media.meanScore != null
+                        ? ` - Community: ${e.media.meanScore}`
+                        : "";
+                    const genres = e.media.genres.length > 0
+                        ? `  Genres: ${e.media.genres.join(", ")}`
+                        : "";
+                    lines.push(`${title} (${format})${community}`);
+                    if (genres)
+                        lines.push(genres);
+                    lines.push(`  Media ID: ${e.media.id}`);
+                }
+                lines.push("", "Use anilist_rate with the media ID to score each title.");
+                return lines.join("\n");
+            }
+            catch (error) {
+                return throwToolError(error, "listing unscored titles");
+            }
+        },
+    });
+    // === Batch Update ===
+    server.addTool({
+        name: "anilist_batch_update",
+        description: "Apply a bulk action to multiple list entries matching a filter. " +
+            "Use when the user wants to move all low-scored titles to Dropped, " +
+            "add all planning titles to current, or bulk-change statuses. " +
+            "Defaults to dry-run mode (preview only). Requires ANILIST_TOKEN.",
+        parameters: BatchUpdateInputSchema,
+        annotations: {
+            title: "Batch Update",
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+        execute: async (args) => {
+            try {
+                requireAuth();
+                const username = getDefaultUsername(args.username);
+                // Fetch entries, optionally filtering by status
+                const entries = await anilistClient.fetchList(username, args.type, args.filter.status);
+                // Apply client-side filters
+                let matched = entries;
+                const { scoreBelow, scoreAbove } = args.filter;
+                if (scoreBelow !== undefined) {
+                    matched = matched.filter((e) => e.score > 0 && e.score < scoreBelow);
+                }
+                if (scoreAbove !== undefined) {
+                    matched = matched.filter((e) => e.score > 0 && e.score > scoreAbove);
+                }
+                if (args.filter.unscored) {
+                    matched = matched.filter((e) => e.score === 0);
+                }
+                // Cap at limit
+                matched = matched.slice(0, args.limit);
+                if (matched.length === 0) {
+                    return "No entries match the specified filter.";
+                }
+                // Build action description
+                const actionParts = [];
+                if (args.action.setStatus)
+                    actionParts.push(`status -> ${args.action.setStatus}`);
+                if (args.action.setScore !== undefined)
+                    actionParts.push(`score -> ${args.action.setScore}`);
+                const actionStr = actionParts.join(", ");
+                if (args.dryRun) {
+                    // Preview mode
+                    const lines = [
+                        `# Batch Update Preview`,
+                        "",
+                        `Action: ${actionStr}`,
+                        `Matched: ${matched.length} entries`,
+                        "",
+                    ];
+                    for (const e of matched.slice(0, 20)) {
+                        const title = getTitle(e.media.title);
+                        const format = e.media.format ?? "?";
+                        const score = e.score > 0 ? `, score ${e.score}` : "";
+                        lines.push(`  ${title} (${format}) - ${e.status}${score}`);
+                    }
+                    if (matched.length > 20) {
+                        lines.push(`  ... and ${matched.length - 20} more`);
+                    }
+                    lines.push("", "Run again with dryRun: false to apply.");
+                    return lines.join("\n");
+                }
+                // Execute mutations
+                const snapshots = [];
+                let successes = 0;
+                let failures = 0;
+                for (const e of matched) {
+                    try {
+                        // Snapshot before mutation
+                        const before = {
+                            id: e.id,
+                            mediaId: e.media.id,
+                            status: e.status,
+                            score: e.score,
+                            progress: e.progress,
+                            notes: e.notes,
+                            private: false,
+                        };
+                        const vars = { mediaId: e.media.id };
+                        if (args.action.setStatus)
+                            vars.status = args.action.setStatus;
+                        if (args.action.setScore !== undefined)
+                            vars.scoreRaw = Math.round(args.action.setScore * 10);
+                        await anilistClient.query(SAVE_MEDIA_LIST_ENTRY_MUTATION, vars, { cache: null });
+                        snapshots.push({ before });
+                        successes++;
+                    }
+                    catch {
+                        failures++;
+                    }
+                }
+                anilistClient.clearCache();
+                invalidateUserProfiles(await getViewerName());
+                // Track batch for undo
+                if (snapshots.length > 0) {
+                    pushUndo({
+                        operation: { type: "batch", entries: snapshots },
+                        toolName: "anilist_batch_update",
+                        timestamp: Date.now(),
+                        description: `Batch: ${actionStr} on ${snapshots.length} entries`,
+                    });
+                }
+                const lines = [
+                    `# Batch Update Complete`,
+                    "",
+                    `Updated ${successes} of ${matched.length} entries (${actionStr}).`,
+                ];
+                if (failures > 0)
+                    lines.push(`${failures} entries failed.`);
+                if (snapshots.length > 0)
+                    lines.push(`Say "undo" to revert all ${snapshots.length} changes.`);
+                return lines.join("\n");
+            }
+            catch (error) {
+                return throwToolError(error, "batch updating entries");
+            }
+        },
+    });
 }

package/dist/types.d.ts

@@ -282,6 +282,18 @@ export interface CharacterSearchResponse {
         }>;
     };
 }
+/** Single list entry snapshot for undo support */
+export interface MediaListEntryResponse {
+    MediaList: {
+        id: number;
+        mediaId: number;
+        status: string;
+        score: number;
+        progress: number;
+        notes: string | null;
+        private: boolean;
+    } | null;
+}
 /** Response from saving a list entry */
 export interface SaveMediaListEntryResponse {
     SaveMediaListEntry: {

package/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": "0.3",
   "name": "ani-mcp",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "display_name": "AniList MCP",
   "description": "A smart MCP server for AniList that gets your anime/manga taste - not just API calls.",
   "author": {
@@ -164,6 +164,15 @@
     },
     {
       "name": "anilist_pace"
+    },
+    {
+      "name": "anilist_undo"
+    },
+    {
+      "name": "anilist_unscored"
+    },
+    {
+      "name": "anilist_batch_update"
     }
   ]
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ani-mcp",
   "mcpName": "io.github.gavxm/ani-mcp",
-  "version": "0.7.0",
+  "version": "0.8.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.7.0",
+  "version": "0.8.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "ani-mcp",
-      "version": "0.7.0",
+      "version": "0.8.0",
       "transport": {
         "type": "stdio"
       },