@vheins/local-memory-mcp 0.13.2 → 0.14.1

package/dist/mcp/server.js

@@ -1,11 +1,6 @@
 #!/usr/bin/env node
 import {
   CAPABILITIES,
-  ClaimListSchema,
-  ClaimReleaseSchema,
-  HandoffCreateSchema,
-  HandoffListSchema,
-  HandoffUpdateSchema,
   LOG_LEVEL_VALUES,
   MCP_PROTOCOL_VERSION,
   MemoryAcknowledgeSchema,
@@ -25,18 +20,19 @@ import {
   StandardStoreSchema,
   StandardUpdateSchema,
   TOOL_DEFINITIONS,
-  TaskClaimSchema,
   TaskCreateInteractiveSchema,
   TaskCreateSchema,
   TaskDeleteSchema,
   TaskGetSchema,
   TaskListSchema,
+  TaskSearchSchema,
   TaskUpdateSchema,
   addLogSink,
   buildStandardVectorText,
   completePromptArgument,
   completeResourceArgument,
   createFileSink,
+  createMcpResponse,
   createSessionContext,
   decodeCursor,
   encodeCursor,
@@ -44,7 +40,14 @@ import {
   findContainingRoot,
   getFilesystemRoots,
   getLogLevel,
+  getPrimaryTextContent,
   getPrompt,
+  handleClaimList,
+  handleClaimRelease,
+  handleHandoffCreate,
+  handleHandoffList,
+  handleHandoffUpdate,
+  handleTaskClaim,
   inferRepoFromSession,
   isPathWithinRoots,
   listPrompts,
@@ -57,7 +60,7 @@ import {
   toContextSlug,
   updateSessionFromInitialize,
   updateSessionRoots
-} from "../chunk-O4B6AFYU.js";
+} from "../chunk-XSGQS2MU.js";
 
 // src/mcp/server.ts
 import readline from "readline";
@@ -186,111 +189,6 @@ function invalidCompletionParams(message) {
 
 // src/mcp/tools/memory.store.ts
 import { randomUUID } from "crypto";
-
-// src/mcp/utils/mcp-response.ts
-import { z } from "zod";
-var McpAnnotationsSchema = z.object({
-  audience: z.array(z.enum(["user", "assistant"])).optional(),
-  priority: z.number().min(0).max(1).optional(),
-  lastModified: z.string().optional()
-}).strict().optional();
-var McpContentSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("text"),
-    text: z.string(),
-    annotations: McpAnnotationsSchema
-  }),
-  z.object({
-    type: z.literal("image"),
-    data: z.string(),
-    mimeType: z.string(),
-    annotations: McpAnnotationsSchema
-  }),
-  z.object({
-    type: z.literal("resource"),
-    resource: z.object({
-      uri: z.string(),
-      mimeType: z.string().optional(),
-      text: z.string().optional(),
-      annotations: McpAnnotationsSchema
-    })
-  })
-]);
-function createMcpResponse(data, summary, options) {
-  const { structuredContentPathHint, contentSummary, includeSerializedStructuredContent = false } = options || {};
-  void includeSerializedStructuredContent;
-  let finalData = data;
-  if (data && typeof data === "object") {
-    const cloned = JSON.parse(JSON.stringify(data));
-    finalData = cloned;
-    const arrayKeys = ["results", "tasks", "memories", "items"];
-    let foundArray = false;
-    for (const key of arrayKeys) {
-      const value = cloned[key];
-      if (Array.isArray(value)) {
-        cloned[key] = value.map(
-          (item) => pruneMetadata(item)
-        );
-        foundArray = true;
-      }
-    }
-    if (Array.isArray(cloned)) {
-      finalData = cloned.map((item) => pruneMetadata(item));
-    } else if (!foundArray) {
-      finalData = pruneMetadata(cloned);
-    }
-  }
-  const content = [];
-  if (contentSummary && contentSummary.trim().length > 0) {
-    content.push({
-      type: "text",
-      text: contentSummary.trim()
-    });
-  } else if (summary && summary.trim().length > 0) {
-    const pointerText = structuredContentPathHint ? `Read structuredContent.${structuredContentPathHint} for details.` : `Read structuredContent for machine-readable results.`;
-    content.push({
-      type: "text",
-      text: `${summary.trim()} ${pointerText}`
-    });
-  }
-  const response = {
-    structuredContent: finalData,
-    isError: false
-  };
-  if (includeSerializedStructuredContent === false) {
-    delete response.structuredContent;
-  }
-  response.content = content;
-  return response;
-}
-function pruneMetadata(item) {
-  if (!item || typeof item !== "object") return item;
-  const pruned = { ...item };
-  const toRemove = [
-    "hit_count",
-    "recall_count",
-    "last_used_at",
-    "expires_at",
-    "agent",
-    "role",
-    "model",
-    "recall_rate",
-    "vector_version",
-    "similarity"
-    // Similarity is useful but adds noise if many results
-  ];
-  for (const field of toRemove) {
-    delete pruned[field];
-  }
-  return pruned;
-}
-function getPrimaryTextContent(response) {
-  if (!Array.isArray(response.content)) return "";
-  const textItem = response.content.find((item) => item.type === "text");
-  return textItem?.type === "text" ? textItem.text : "";
-}
-
-// src/mcp/tools/memory.store.ts
 function hasMetadataLikeTitle(title) {
   const normalized = title.trim();
   return /^\[[^\]]{0,200}(agent:|role:|model:|\d{4}-\d{2}-\d{2}|source_)[^\]]*\]/i.test(normalized);
@@ -311,9 +209,10 @@ async function handleMemoryStore(params, db2, vectors2) {
     );
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const expires_at = validated.ttlDays != null ? new Date(Date.now() + validated.ttlDays * 864e5).toISOString() : null;
+  const createdAtTime = new Date(now).getTime();
+  const expires_at = validated.ttlDays != null ? new Date(createdAtTime + validated.ttlDays * 864e5).toISOString() : null;
   if (!validated.supersedes && validated.type !== "task_archive") {
-    const conflict = await db2.memories.checkConflicts(
+    const conflict = await db2.memoryVectors.checkConflicts(
       validated.content,
       validated.scope.repo,
       validated.type,
@@ -508,7 +407,7 @@ async function handleMemorySearch(params, db2, vectors2) {
   const validated = MemorySearchSchema.parse(params);
   const searchQuery = expandQuery(validated.query, validated.prompt);
   const fetchLimit = (validated.offset + validated.limit) * 3;
-  const similarityResults = db2.memories.searchBySimilarity(
+  const similarityResults = db2.memoryVectors.searchBySimilarity(
     searchQuery,
     validated.repo,
     fetchLimit,
@@ -824,7 +723,7 @@ function deriveTaskStatusTimestamps(status, now, existingTask) {
 async function archiveTaskToMemory(taskId, repo, storage, vectors2) {
   const task = storage.tasks.getTaskById(taskId);
   if (!task) return;
-  const comments = storage.tasks.getTaskCommentsByTaskId(taskId);
+  const comments = storage.taskComments.getTaskCommentsByTaskId(taskId);
   let content = `Task: [${task.task_code}] ${task.title}
 `;
   content += `Phase: ${task.phase}
@@ -940,7 +839,7 @@ async function handleTaskCreate(args, storage) {
     const createdTasks = [];
     const now2 = (/* @__PURE__ */ new Date()).toISOString();
     const codesInRequest = /* @__PURE__ */ new Set();
-    const initialStats = storage.tasks.getTaskStats(repo);
+    const initialStats = storage.taskStats.getTaskStats(repo);
     let pendingInRequestCount = 0;
     for (const taskData of bulkTasks) {
       if (codesInRequest.has(taskData.task_code)) {
@@ -988,6 +887,8 @@ async function handleTaskCreate(args, storage) {
         canceled_at: statusTimestamps2.canceled_at,
         est_tokens: taskData.est_tokens ?? 0,
         tags,
+        commit_id: null,
+        changed_files: [],
         metadata: taskData.metadata || {},
         parent_id: resolveParentId(taskData.parent_id, repo, storage),
         depends_on: taskData.depends_on || null
@@ -1030,9 +931,11 @@ async function handleTaskCreate(args, storage) {
     throw new Error("New tasks must be created with status 'backlog' or 'pending'.");
   }
   if (status === "pending") {
-    const stats = storage.tasks.getTaskStats(repo);
+    const stats = storage.taskStats.getTaskStats(repo);
     if (stats.todo >= 10) {
-      throw new Error(`Cannot create task as 'pending'. Maximum of 10 pending tasks reached. Please use status 'backlog' for new tasks instead.`);
+      throw new Error(
+        `Cannot create task as 'pending'. Maximum of 10 pending tasks reached. Please use status 'backlog' for new tasks instead.`
+      );
     }
   }
   const taskId = randomUUID2();
@@ -1062,6 +965,8 @@ async function handleTaskCreate(args, storage) {
     canceled_at: statusTimestamps.canceled_at,
     est_tokens: est_tokens ?? 0,
     tags: finalTags,
+    commit_id: null,
+    changed_files: [],
     metadata: metadata || {},
     parent_id: resolveParentId(parent_id, repo, storage),
     depends_on: depends_on || null
@@ -1255,7 +1160,7 @@ async function handleTaskUpdate(args, storage, vectors2) {
       finalUpdates.in_progress_at = now;
     storage.tasks.updateTask(targetId, finalUpdates);
     if (comment !== void 0 || isStatusChanging) {
-      storage.tasks.insertTaskComment({
+      storage.taskComments.insertTaskComment({
         id: randomUUID2(),
         task_id: targetId,
         repo,
@@ -1603,21 +1508,29 @@ async function handleMemoryDelete(params, db2, vectors2, onProgress) {
   let lastRepo = repo || "unknown";
   const total = targetIds.length;
   let progress = 0;
+  const existingMemories = db2.memories.getByIds(targetIds);
+  const existingMap = new Map(existingMemories.map((m) => [m.id, m]));
+  const validIdsToDelete = [];
   for (const targetId of targetIds) {
-    if (onProgress) {
-      onProgress(progress, total);
-    }
-    const existing = db2.memories.getById(targetId);
+    const existing = existingMap.get(targetId);
     if (existing) {
       lastRepo = existing.scope.repo;
       deletedCodes.push(existing.code || existing.id);
-      db2.memories.delete(targetId);
-      await vectors2.remove(targetId);
-      deletedCount++;
+      validIdsToDelete.push(targetId);
     } else if (id) {
       throw new Error(`Memory not found: ${targetId}`);
     }
-    progress++;
+  }
+  if (validIdsToDelete.length > 0) {
+    db2.memoryArchives.bulkDeleteMemories(validIdsToDelete);
+    for (const validId of validIdsToDelete) {
+      if (onProgress) {
+        onProgress(progress, total);
+      }
+      await vectors2.remove(validId);
+      progress++;
+    }
+    deletedCount = validIdsToDelete.length;
   }
   if (onProgress) {
     onProgress(progress, total);
@@ -1714,266 +1627,6 @@ async function handleMemoryDetail(args, storage) {
   });
 }
 
-// src/mcp/tools/handoff.manage.ts
-function buildHandoffListSummary(repo, count, status, fromAgent, toAgent) {
-  const parts = [`Found ${count} handoff${count === 1 ? "" : "s"} in repo "${repo}".`];
-  if (status) {
-    parts.push(`Status filter: ${status}.`);
-  }
-  if (fromAgent) {
-    parts.push(`From agent: ${fromAgent}.`);
-  }
-  if (toAgent) {
-    parts.push(`To agent: ${toAgent}.`);
-  }
-  return parts.join("\n");
-}
-function buildClaimListSummary(repo, count, agent, activeOnly) {
-  const parts = [`Found ${count} claim${count === 1 ? "" : "s"} in repo "${repo}".`];
-  if (agent) {
-    parts.push(`Agent filter: ${agent}.`);
-  }
-  if (activeOnly) {
-    parts.push("Showing active claims only.");
-  }
-  return parts.join("\n");
-}
-async function handleHandoffCreate(args, storage) {
-  const validated = HandoffCreateSchema.parse(args);
-  const { repo, from_agent, to_agent, task_id, task_code, summary, context, expires_at, structured } = validated;
-  let resolvedTaskId = task_id ?? null;
-  if (!resolvedTaskId && task_code) {
-    const task = storage.tasks.getTaskByCode(repo, task_code);
-    if (!task) {
-      throw new Error(`Task not found: ${task_code} in repo ${repo}`);
-    }
-    resolvedTaskId = task.id;
-  }
-  const handoff = storage.handoffs.createHandoff({
-    repo,
-    from_agent,
-    to_agent,
-    task_id: resolvedTaskId,
-    summary,
-    context,
-    expires_at
-  });
-  const contentSummary = [
-    `Created handoff ${handoff.id}.`,
-    `Repo: ${handoff.repo}`,
-    `From: ${handoff.from_agent}`,
-    `To: ${handoff.to_agent || "unassigned"}`,
-    `Status: ${handoff.status}`,
-    `Task ID: ${handoff.task_id || "-"}`,
-    `Summary: ${handoff.summary}`
-  ].join("\n");
-  return createMcpResponse(handoff, contentSummary, {
-    contentSummary,
-    includeSerializedStructuredContent: structured
-  });
-}
-async function handleHandoffList(args, storage) {
-  const validated = HandoffListSchema.parse(args);
-  const { repo, status, from_agent, to_agent, limit, offset, structured } = validated;
-  const handoffs = storage.handoffs.listHandoffs({
-    repo,
-    status,
-    from_agent,
-    to_agent,
-    limit,
-    offset
-  });
-  const COLUMNS = [
-    "id",
-    "from_agent",
-    "to_agent",
-    "task_id",
-    "task_code",
-    "status",
-    "created_at",
-    "updated_at",
-    "expires_at",
-    "summary",
-    "context"
-  ];
-  const rows = handoffs.map((handoff) => [
-    handoff.id,
-    handoff.from_agent,
-    handoff.to_agent,
-    handoff.task_id,
-    handoff.task_code ?? null,
-    handoff.status,
-    handoff.created_at,
-    handoff.updated_at,
-    handoff.expires_at,
-    handoff.summary,
-    handoff.context
-  ]);
-  const structuredData = {
-    schema: "handoff-list",
-    handoffs: {
-      columns: [...COLUMNS],
-      rows
-    },
-    count: rows.length,
-    offset
-  };
-  const contentSummary = buildHandoffListSummary(repo, rows.length, status, from_agent, to_agent);
-  return createMcpResponse(structuredData, contentSummary, {
-    contentSummary,
-    includeSerializedStructuredContent: structured
-  });
-}
-async function handleHandoffUpdate(args, storage) {
-  const validated = HandoffUpdateSchema.parse(args);
-  const { id, status, structured } = validated;
-  const existing = storage.handoffs.getHandoffById(id);
-  if (!existing) {
-    throw new Error(`Handoff not found: ${id}`);
-  }
-  const success = storage.handoffs.updateHandoffStatus(id, status);
-  if (!success) {
-    throw new Error(`Failed to update handoff: ${id}`);
-  }
-  const updated = storage.handoffs.getHandoffById(id);
-  const result = {
-    success,
-    id,
-    status,
-    handoff: updated
-  };
-  const contentSummary = [`Updated handoff ${id}.`, `Status: ${status}`].join("\n");
-  return createMcpResponse(result, contentSummary, {
-    contentSummary,
-    includeSerializedStructuredContent: structured
-  });
-}
-async function handleTaskClaim(args, storage) {
-  const validated = TaskClaimSchema.parse(args);
-  const { repo, task_id, task_code, agent, role, metadata, structured } = validated;
-  let taskId = task_id;
-  let resolvedTaskCode;
-  if (taskId) {
-    const task = storage.tasks.getTaskById(taskId);
-    if (!task || task.repo !== repo) {
-      throw new Error(`Task not found: ${taskId} in repo ${repo}`);
-    }
-    resolvedTaskCode = task.task_code;
-  } else if (task_code) {
-    const task = storage.tasks.getTaskByCode(repo, task_code);
-    if (!task) {
-      throw new Error(`Task not found: ${task_code} in repo ${repo}`);
-    }
-    taskId = task.id;
-    resolvedTaskCode = task.task_code;
-  } else {
-    throw new Error("Either task_id or task_code must be provided");
-  }
-  const claim = storage.handoffs.claimTask({
-    repo,
-    task_id: taskId,
-    agent,
-    role,
-    metadata
-  });
-  const responseData = {
-    ...claim,
-    task_code: resolvedTaskCode
-  };
-  const contentSummary = [
-    `Claimed task ${resolvedTaskCode || claim.task_id}.`,
-    `Repo: ${claim.repo}`,
-    `Task ID: ${claim.task_id}`,
-    `Agent: ${claim.agent}`,
-    `Role: ${claim.role}`,
-    `Claimed At: ${claim.claimed_at}`
-  ].join("\n");
-  const response = createMcpResponse(responseData, contentSummary, {
-    contentSummary,
-    includeSerializedStructuredContent: structured
-  });
-  if (structured) {
-    response.structuredContent = responseData;
-  }
-  return response;
-}
-async function handleClaimList(args, storage) {
-  const validated = ClaimListSchema.parse(args);
-  const { repo, agent, active_only, limit, offset, structured } = validated;
-  const claims = storage.handoffs.listClaims({
-    repo,
-    agent,
-    active_only,
-    limit,
-    offset
-  });
-  const COLUMNS = ["id", "task_id", "task_code", "agent", "role", "claimed_at", "released_at", "metadata"];
-  const rows = claims.map((claim) => [
-    claim.id,
-    claim.task_id,
-    claim.task_code ?? null,
-    claim.agent,
-    claim.role,
-    claim.claimed_at,
-    claim.released_at,
-    claim.metadata
-  ]);
-  const structuredData = {
-    schema: "claim-list",
-    claims: {
-      columns: [...COLUMNS],
-      rows
-    },
-    count: rows.length,
-    offset
-  };
-  const contentSummary = buildClaimListSummary(repo, rows.length, agent, active_only);
-  return createMcpResponse(structuredData, contentSummary, {
-    contentSummary,
-    includeSerializedStructuredContent: structured
-  });
-}
-async function handleClaimRelease(args, storage) {
-  const validated = ClaimReleaseSchema.parse(args);
-  const { repo, task_id, task_code, agent, structured } = validated;
-  let resolvedTaskId = task_id;
-  let resolvedTaskCode = task_code ?? null;
-  if (resolvedTaskId) {
-    const task = storage.tasks.getTaskById(resolvedTaskId);
-    if (!task || task.repo !== repo) {
-      throw new Error(`Task not found: ${resolvedTaskId} in repo ${repo}`);
-    }
-    resolvedTaskCode = task.task_code;
-  } else if (task_code) {
-    const task = storage.tasks.getTaskByCode(repo, task_code);
-    if (!task) {
-      throw new Error(`Task not found: ${task_code} in repo ${repo}`);
-    }
-    resolvedTaskId = task.id;
-    resolvedTaskCode = task.task_code;
-  }
-  const success = storage.handoffs.releaseClaim(resolvedTaskId, agent);
-  if (!success) {
-    throw new Error(`No active claim found for task ${resolvedTaskCode || resolvedTaskId}`);
-  }
-  const result = {
-    success,
-    repo,
-    task_id: resolvedTaskId,
-    task_code: resolvedTaskCode,
-    agent: agent ?? null
-  };
-  const contentSummary = [
-    `Released claim for task ${resolvedTaskCode || resolvedTaskId}.`,
-    `Repo: ${repo}`,
-    agent ? `Agent: ${agent}` : "Agent: any active claimant"
-  ].join("\n");
-  return createMcpResponse(result, contentSummary, {
-    contentSummary,
-    includeSerializedStructuredContent: structured
-  });
-}
-
 // src/mcp/tools/standard.store.ts
 import { randomUUID as randomUUID3 } from "crypto";
 function generateShortCode2() {
@@ -2451,7 +2104,7 @@ async function handleTaskGet(args, storage) {
   if (!task) {
     throw new Error(`Task not found: ${id || task_code} in repo ${repo}`);
   }
-  const comments = storage.tasks.getTaskCommentsByTaskId(task.id);
+  const comments = storage.taskComments.getTaskCommentsByTaskId(task.id);
   let contentSummary;
   if (!isStructuredRequest) {
     const lines = [
@@ -2488,6 +2141,62 @@ async function handleTaskGet(args, storage) {
   });
 }
 
+// src/mcp/tools/task.search.ts
+async function handleTaskSearch(args, storage) {
+  const validated = TaskSearchSchema.parse(args);
+  const { repo, query, status, limit, offset, structured: isStructuredRequest = false, phase, priority } = validated;
+  let tasks;
+  if (status) {
+    const statuses = status.split(",").map((s) => s.trim()).filter(Boolean);
+    if (statuses.length > 1) {
+      tasks = storage.tasks.getTasksByMultipleStatuses(repo, statuses, void 0, void 0, query);
+    } else {
+      tasks = storage.tasks.getTasksByRepo(repo, status, void 0, void 0, query);
+    }
+  } else {
+    tasks = storage.tasks.getTasksByRepo(repo, void 0, void 0, void 0, query);
+  }
+  if (phase) {
+    const phaseLower = phase.toLowerCase();
+    tasks = tasks.filter((t) => t.phase && t.phase.toLowerCase() === phaseLower);
+  }
+  if (priority !== void 0) {
+    tasks = tasks.filter((t) => t.priority === priority);
+  }
+  const total = tasks.length;
+  const paginated = tasks.slice(offset, offset + limit);
+  const COLUMNS = ["id", "task_code", "title", "status", "priority", "updated_at", "phase"];
+  const rows = paginated.map((t) => [t.id, t.task_code, t.title, t.status, t.priority, t.updated_at, t.phase]);
+  const structuredData = {
+    schema: "task-search",
+    query,
+    count: paginated.length,
+    total,
+    offset,
+    limit,
+    results: {
+      columns: [...COLUMNS],
+      rows
+    }
+  };
+  let contentSummary;
+  if (!isStructuredRequest) {
+    contentSummary = paginated.length > 0 ? `Found ${total} tasks matching "${query}" in repo "${repo}". Use task-detail to fetch full task content.` : `No tasks found for "${query}" in repo "${repo}".`;
+  }
+  logger.info("[Tool] task.search", {
+    repo,
+    query,
+    total,
+    offset,
+    returned: paginated.length
+  });
+  return createMcpResponse(structuredData, contentSummary || `Found ${total} tasks for "${query}".`, {
+    contentSummary,
+    structuredContentPathHint: "results",
+    includeSerializedStructuredContent: isStructuredRequest
+  });
+}
+
 // src/mcp/router.ts
 function createRouter(db2, vectors2, options) {
   const getSessionContext = options?.getSessionContext;
@@ -2639,6 +2348,8 @@ function createRouter(db2, vectors2, options) {
           return await handleTaskDelete(args, db2);
         case "task-list":
           return await handleTaskList(args, db2);
+        case "task-search":
+          return await handleTaskSearch(args, db2);
         case "task-detail":
           return await handleTaskGet(args, db2);
         default:
@@ -2813,8 +2524,8 @@ logger.info("[Server] startup", { pid: process.pid, version: CAPABILITIES.server
 vectors.initialize().catch((err) => {
   logger.warn("[Server] Initial vector model loading failed. Will retry on first use.", { error: String(err) });
 });
-var expiredArchived = db.memories.archiveExpiredMemories();
-var lowScoreArchived = db.memories.archiveLowScoreMemories();
+var expiredArchived = db.memoryArchives.archiveExpiredMemories();
+var lowScoreArchived = db.memoryArchives.archiveLowScoreMemories();
 var totalArchived = (expiredArchived || 0) + (lowScoreArchived || 0);
 if (totalArchived > 0) {
   logger.info(
@@ -2835,9 +2546,7 @@ var logNotificationsEnabled = false;
 var handleMethod = createRouter(db, vectors, {
   getSessionContext: () => session,
   sampleMessage: (params) => requestClient("sampling/createMessage", params),
-  // eslint-disable-line @typescript-eslint/no-explicit-any
   elicit: (params) => requestClient("elicitation/create", params),
-  // eslint-disable-line @typescript-eslint/no-explicit-any
   onResourcesMutated: (uris) => notifyUpdatedResources(uris)
 });
 addLogSink((payload) => {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vheins/local-memory-mcp",
-	"version": "0.13.2",
+	"version": "0.14.1",
 	"description": "MCP Local Memory Service for coding copilot agents",
 	"mcpName": "io.github.vheins/local-memory-mcp",
 	"type": "module",
@@ -68,6 +68,7 @@
 		"@types/node": "^22.19.7",
 		"@typescript-eslint/eslint-plugin": "^8.58.1",
 		"@typescript-eslint/parser": "^8.58.1",
+		"@vitest/coverage-v8": "^4.1.7",
 		"eslint": "^10.2.0",
 		"eslint-config-prettier": "^10.1.8",
 		"eslint-plugin-prettier": "^5.5.5",
@@ -85,7 +86,7 @@
 		"typescript": "^5.7.3",
 		"typescript-eslint": "^8.58.1",
 		"vite": "^8.0.6",
-		"vitest": "^4.1.1"
+		"vitest": "^4.1.7"
 	},
 	"overrides": {
 		"protobufjs": "^7.5.5"