@mpowr/nexus-mcp 0.5.0

package/src/__tests__/reviews.test.ts

@@ -0,0 +1,420 @@
+/**
+ * Tests for review lifecycle tools:
+ * - rv_list
+ * - rv_get
+ * - rv_create
+ * - rv_decide
+ * - rv_comment
+ *
+ * All tools delegate to the Nexus API via nexusPost().
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { mockApiError, mockApiSuccess, parseToolResponse, TEST_IDS } from './helpers'
+
+vi.mock('../nexus-api.js', () => ({
+  nexusPost: vi.fn(),
+}))
+
+import { nexusPost } from '../nexus-api.js'
+
+// ---------------------------------------------------------------------------
+// rv_list
+// ---------------------------------------------------------------------------
+
+describe('rv_list', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('should return a list of reviews', async () => {
+    vi.mocked(nexusPost).mockResolvedValue(
+      mockApiSuccess({
+        action: 'rv_list',
+        count: 2,
+        reviews: [
+          {
+            id: TEST_IDS.reviewId,
+            entity_type: 'skill',
+            entity_id: TEST_IDS.skillId,
+            status: 'pending',
+            created_at: '2026-04-12T00:00:00Z',
+          },
+          {
+            id: '22222222-1111-1111-1111-111111111111',
+            entity_type: 'agent',
+            entity_id: TEST_IDS.agentId,
+            status: 'accepted',
+            created_at: '2026-04-11T00:00:00Z',
+          },
+        ],
+      }),
+    )
+
+    const { rvList } = await import('../tools/reviews.js')
+    const result = await rvList({ user_id: TEST_IDS.userId })
+
+    expect(result.isError).toBeUndefined()
+    const parsed = parseToolResponse(result)
+    expect(parsed.action).toBe('rv_list')
+    expect(parsed.count).toBe(2)
+    expect(parsed.reviews).toHaveLength(2)
+    expect(parsed.reviews[0].id).toBe(TEST_IDS.reviewId)
+  })
+
+  it('should filter by entity_type', async () => {
+    vi.mocked(nexusPost).mockResolvedValue(
+      mockApiSuccess({
+        action: 'rv_list',
+        count: 1,
+        reviews: [
+          {
+            id: TEST_IDS.reviewId,
+            entity_type: 'skill',
+            entity_id: TEST_IDS.skillId,
+            status: 'pending',
+          },
+        ],
+      }),
+    )
+
+    const { rvList } = await import('../tools/reviews.js')
+    const result = await rvList({
+      entity_type: 'skill',
+      user_id: TEST_IDS.userId,
+    })
+
+    expect(result.isError).toBeUndefined()
+    const parsed = parseToolResponse(result)
+    expect(parsed.count).toBe(1)
+    expect(parsed.reviews[0].entity_type).toBe('skill')
+
+    expect(nexusPost).toHaveBeenCalledWith('/api/mcp/reviews', {
+      action: 'rv_list',
+      entity_type: 'skill',
+      status: undefined,
+      limit: undefined,
+    })
+  })
+
+  it('should return error on API failure', async () => {
+    vi.mocked(nexusPost).mockResolvedValue(mockApiError('Internal server error', 500))
+
+    const { rvList } = await import('../tools/reviews.js')
+    const result = await rvList({ user_id: TEST_IDS.userId })
+
+    expect(result.isError).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// rv_get
+// ---------------------------------------------------------------------------
+
+describe('rv_get', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('should get a review by review_id', async () => {
+    vi.mocked(nexusPost).mockResolvedValue(
+      mockApiSuccess({
+        action: 'rv_get',
+        review: {
+          id: TEST_IDS.reviewId,
+          entity_type: 'skill',
+          entity_id: TEST_IDS.skillId,
+          status: 'pending',
+          created_at: '2026-04-12T00:00:00Z',
+          comments: [],
+        },
+      }),
+    )
+
+    const { rvGet } = await import('../tools/reviews.js')
+    const result = await rvGet({
+      review_id: TEST_IDS.reviewId,
+      user_id: TEST_IDS.userId,
+    })
+
+    expect(result.isError).toBeUndefined()
+    const parsed = parseToolResponse(result)
+    expect(parsed.action).toBe('rv_get')
+    expect(parsed.review.id).toBe(TEST_IDS.reviewId)
+    expect(parsed.review.entity_type).toBe('skill')
+  })
+
+  it('should get a review by entity_type and entity_id', async () => {
+    vi.mocked(nexusPost).mockResolvedValue(
+      mockApiSuccess({
+        action: 'rv_get',
+        review: {
+          id: TEST_IDS.reviewId,
+          entity_type: 'skill',
+          entity_id: TEST_IDS.skillId,
+          status: 'pending',
+        },
+      }),
+    )
+
+    const { rvGet } = await import('../tools/reviews.js')
+    const result = await rvGet({
+      entity_type: 'skill',
+      entity_id: TEST_IDS.skillId,
+      user_id: TEST_IDS.userId,
+    })
+
+    expect(result.isError).toBeUndefined()
+    const parsed = parseToolResponse(result)
+    expect(parsed.review.entity_type).toBe('skill')
+    expect(parsed.review.entity_id).toBe(TEST_IDS.skillId)
+
+    expect(nexusPost).toHaveBeenCalledWith('/api/mcp/reviews', {
+      action: 'rv_get',
+      review_id: undefined,
+      entity_type: 'skill',
+      entity_id: TEST_IDS.skillId,
+    })
+  })
+
+  it('should return error on API failure', async () => {
+    vi.mocked(nexusPost).mockResolvedValue(mockApiError('Review not found', 404))
+
+    const { rvGet } = await import('../tools/reviews.js')
+    const result = await rvGet({
+      review_id: TEST_IDS.reviewId,
+      user_id: TEST_IDS.userId,
+    })
+
+    expect(result.isError).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// rv_create
+// ---------------------------------------------------------------------------
+
+describe('rv_create', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('should create a review for an entity', async () => {
+    vi.mocked(nexusPost).mockResolvedValue(
+      mockApiSuccess({
+        action: 'rv_create',
+        review_id: TEST_IDS.reviewId,
+        entity_type: 'skill',
+        entity_id: TEST_IDS.skillId,
+        status: 'pending',
+      }),
+    )
+
+    const { rvCreate } = await import('../tools/reviews.js')
+    const result = await rvCreate({
+      entity_type: 'skill',
+      entity_id: TEST_IDS.skillId,
+      user_id: TEST_IDS.userId,
+    })
+
+    expect(result.isError).toBeUndefined()
+    const parsed = parseToolResponse(result)
+    expect(parsed.action).toBe('rv_create')
+    expect(parsed.review_id).toBe(TEST_IDS.reviewId)
+    expect(parsed.entity_type).toBe('skill')
+    expect(parsed.status).toBe('pending')
+  })
+
+  it('should return error on duplicate review (409)', async () => {
+    vi.mocked(nexusPost).mockResolvedValue(
+      mockApiError('Review already exists for this entity', 409),
+    )
+
+    const { rvCreate } = await import('../tools/reviews.js')
+    const result = await rvCreate({
+      entity_type: 'skill',
+      entity_id: TEST_IDS.skillId,
+      user_id: TEST_IDS.userId,
+    })
+
+    expect(result.isError).toBe(true)
+    const parsed = parseToolResponse(result)
+    expect(parsed.error).toBe('Review already exists for this entity')
+  })
+
+  it('should return error on API failure', async () => {
+    vi.mocked(nexusPost).mockResolvedValue(mockApiError('Entity not found', 404))
+
+    const { rvCreate } = await import('../tools/reviews.js')
+    const result = await rvCreate({
+      entity_type: 'skill',
+      entity_id: TEST_IDS.skillId,
+      user_id: TEST_IDS.userId,
+    })
+
+    expect(result.isError).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// rv_decide
+// ---------------------------------------------------------------------------
+
+describe('rv_decide', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('should accept a review', async () => {
+    vi.mocked(nexusPost).mockResolvedValue(
+      mockApiSuccess({
+        action: 'rv_decide',
+        review_id: TEST_IDS.reviewId,
+        transition: 'accept',
+        previous_status: 'pending',
+        new_status: 'accepted',
+      }),
+    )
+
+    const { rvDecide } = await import('../tools/reviews.js')
+    const result = await rvDecide({
+      review_id: TEST_IDS.reviewId,
+      transition: 'accept',
+      user_id: TEST_IDS.userId,
+    })
+
+    expect(result.isError).toBeUndefined()
+    const parsed = parseToolResponse(result)
+    expect(parsed.action).toBe('rv_decide')
+    expect(parsed.transition).toBe('accept')
+    expect(parsed.new_status).toBe('accepted')
+  })
+
+  it('should reject a review with rationale', async () => {
+    vi.mocked(nexusPost).mockResolvedValue(
+      mockApiSuccess({
+        action: 'rv_decide',
+        review_id: TEST_IDS.reviewId,
+        transition: 'reject',
+        previous_status: 'pending',
+        new_status: 'rejected',
+      }),
+    )
+
+    const { rvDecide } = await import('../tools/reviews.js')
+    const result = await rvDecide({
+      review_id: TEST_IDS.reviewId,
+      transition: 'reject',
+      rationale: 'Does not meet quality standards',
+      user_id: TEST_IDS.userId,
+    })
+
+    expect(result.isError).toBeUndefined()
+    const parsed = parseToolResponse(result)
+    expect(parsed.transition).toBe('reject')
+    expect(parsed.new_status).toBe('rejected')
+
+    expect(nexusPost).toHaveBeenCalledWith('/api/mcp/reviews', {
+      action: 'rv_decide',
+      review_id: TEST_IDS.reviewId,
+      transition: 'reject',
+      rationale: 'Does not meet quality standards',
+    })
+  })
+
+  it('should return error on API failure', async () => {
+    vi.mocked(nexusPost).mockResolvedValue(
+      mockApiError('Review must be in pending state', 409),
+    )
+
+    const { rvDecide } = await import('../tools/reviews.js')
+    const result = await rvDecide({
+      review_id: TEST_IDS.reviewId,
+      transition: 'accept',
+      user_id: TEST_IDS.userId,
+    })
+
+    expect(result.isError).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// rv_comment
+// ---------------------------------------------------------------------------
+
+describe('rv_comment', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('should add a comment to a review', async () => {
+    vi.mocked(nexusPost).mockResolvedValue(
+      mockApiSuccess({
+        action: 'rv_comment',
+        comment_id: 'comment-rv-1',
+        review_id: TEST_IDS.reviewId,
+      }),
+    )
+
+    const { rvComment } = await import('../tools/reviews.js')
+    const result = await rvComment({
+      review_id: TEST_IDS.reviewId,
+      body: 'Looks good overall, minor nit on line 42.',
+      user_id: TEST_IDS.userId,
+    })
+
+    expect(result.isError).toBeUndefined()
+    const parsed = parseToolResponse(result)
+    expect(parsed.action).toBe('rv_comment')
+    expect(parsed.comment_id).toBe('comment-rv-1')
+    expect(parsed.review_id).toBe(TEST_IDS.reviewId)
+  })
+
+  it('should support line range for inline comments', async () => {
+    vi.mocked(nexusPost).mockResolvedValue(
+      mockApiSuccess({
+        action: 'rv_comment',
+        comment_id: 'comment-rv-2',
+        review_id: TEST_IDS.reviewId,
+        line_start: 10,
+        line_end: 15,
+      }),
+    )
+
+    const { rvComment } = await import('../tools/reviews.js')
+    const result = await rvComment({
+      review_id: TEST_IDS.reviewId,
+      body: 'This block could be simplified.',
+      line_start: 10,
+      line_end: 15,
+      user_id: TEST_IDS.userId,
+    })
+
+    expect(result.isError).toBeUndefined()
+    const parsed = parseToolResponse(result)
+    expect(parsed.line_start).toBe(10)
+    expect(parsed.line_end).toBe(15)
+
+    expect(nexusPost).toHaveBeenCalledWith('/api/mcp/reviews', {
+      action: 'rv_comment',
+      review_id: TEST_IDS.reviewId,
+      body: 'This block could be simplified.',
+      agent_id: undefined,
+      line_start: 10,
+      line_end: 15,
+    })
+  })
+
+  it('should return error on API failure', async () => {
+    vi.mocked(nexusPost).mockResolvedValue(mockApiError('Review not found', 404))
+
+    const { rvComment } = await import('../tools/reviews.js')
+    const result = await rvComment({
+      review_id: TEST_IDS.reviewId,
+      body: 'Comment on missing review',
+      user_id: TEST_IDS.userId,
+    })
+
+    expect(result.isError).toBe(true)
+  })
+})

package/src/__tests__/server.test.ts

@@ -0,0 +1,238 @@
+/**
+ * Tests for MCP server.ts integration:
+ * - withIdentity wrapper
+ * - Tool registration count (regression guard)
+ * - Schema export verification
+ */
+
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+// We test the withIdentity pattern and schema exports without
+// starting the full server (which needs stdio transport).
+
+describe('MCP Server: withIdentity wrapper', () => {
+  beforeEach(() => {
+    vi.resetModules()
+    vi.restoreAllMocks()
+  })
+
+  it('should inject user_id from identity into handler args', async () => {
+    // Recreate the withIdentity function inline (same logic as server.ts)
+    // with a simple mock identity
+    const mockIdentity = {
+      userId: 'injected-user-id',
+      email: 'test@example.com',
+      displayName: 'Test',
+      isPlatformAdmin: true,
+    }
+
+    function withIdentity(
+      handler: (args: Record<string, unknown>) => Promise<unknown>,
+    ) {
+      return async (args: Record<string, unknown>) => {
+        return handler({ ...args, user_id: mockIdentity.userId })
+      }
+    }
+
+    const mockHandler = vi.fn().mockResolvedValue({ content: [] })
+    const wrapped = withIdentity(mockHandler)
+
+    await wrapped({ project_id: 'test-project', title: 'Test' })
+
+    expect(mockHandler).toHaveBeenCalledWith({
+      project_id: 'test-project',
+      title: 'Test',
+      user_id: 'injected-user-id',
+    })
+  })
+
+  it('should override any user_id passed by the caller', async () => {
+    const mockIdentity = {
+      userId: 'real-user-id',
+      email: 'real@example.com',
+      displayName: 'Real User',
+      isPlatformAdmin: false,
+    }
+
+    function withIdentity(
+      handler: (args: Record<string, unknown>) => Promise<unknown>,
+    ) {
+      return async (args: Record<string, unknown>) => {
+        return handler({ ...args, user_id: mockIdentity.userId })
+      }
+    }
+
+    const mockHandler = vi.fn().mockResolvedValue({ content: [] })
+    const wrapped = withIdentity(mockHandler)
+
+    // Caller tries to inject a different user_id
+    await wrapped({ project_id: 'test', user_id: 'attacker-user-id' })
+
+    // The real identity should override the attacker's
+    expect(mockHandler).toHaveBeenCalledWith(
+      expect.objectContaining({ user_id: 'real-user-id' }),
+    )
+  })
+})
+
+describe('MCP Server: Schema exports', () => {
+  const EXPECTED_TOOL_COUNT = 36
+
+  it('should register exactly 36 tools in server.ts', () => {
+    // Static analysis: count server.tool( calls in server.ts as a regression guard.
+    // If you add or remove a tool, update EXPECTED_TOOL_COUNT above.
+    const serverSource = readFileSync(
+      resolve(__dirname, '../server.ts'),
+      'utf-8',
+    )
+    const matches = serverSource.match(/server\.tool\(/g) || []
+    expect(matches.length).toBe(EXPECTED_TOOL_COUNT)
+  })
+
+  it('should export valid schemas from all tool modules', async () => {
+    // Verify each tool module exports the expected schema + handler
+
+    const searchKnowledge = await import('../tools/search-knowledge.js')
+    expect(searchKnowledge.searchKnowledgeSchema).toBeDefined()
+    expect(searchKnowledge.searchKnowledgeSchema.query).toBeDefined()
+    expect(searchKnowledge.searchKnowledgeSchema.project_id).toBeDefined()
+    expect(typeof searchKnowledge.searchKnowledge).toBe('function')
+
+    const getProjectMemory = await import('../tools/get-project-memory.js')
+    expect(getProjectMemory.getProjectMemorySchema).toBeDefined()
+    expect(typeof getProjectMemory.getProjectMemory).toBe('function')
+
+    const getDocument = await import('../tools/get-document.js')
+    expect(getDocument.getDocumentSchema).toBeDefined()
+    expect(typeof getDocument.getDocument).toBe('function')
+
+    const getRelated = await import('../tools/get-related-entities.js')
+    expect(getRelated.getRelatedEntitiesSchema).toBeDefined()
+    expect(typeof getRelated.getRelatedEntities).toBe('function')
+
+    const createTask = await import('../tools/create-task.js')
+    expect(createTask.createTaskSchema).toBeDefined()
+    expect(createTask.createTaskSchema.project_id).toBeDefined()
+    expect(createTask.createTaskSchema.title).toBeDefined()
+    expect(typeof createTask.createTask).toBe('function')
+
+    const updateTaskStatus = await import('../tools/update-task-status.js')
+    expect(updateTaskStatus.updateTaskStatusSchema).toBeDefined()
+    expect(updateTaskStatus.updateTaskStatusSchema.task_id).toBeDefined()
+    expect(updateTaskStatus.updateTaskStatusSchema.status).toBeDefined()
+    expect(typeof updateTaskStatus.updateTaskStatus).toBe('function')
+
+    const addTaskNote = await import('../tools/add-task-note.js')
+    expect(addTaskNote.addTaskNoteSchema).toBeDefined()
+    expect(addTaskNote.addTaskNoteSchema.task_id).toBeDefined()
+    expect(addTaskNote.addTaskNoteSchema.note).toBeDefined()
+    expect(typeof addTaskNote.addTaskNote).toBe('function')
+
+    const ingestDoc = await import('../tools/ingest-document.js')
+    expect(ingestDoc.ingestDocumentSchema).toBeDefined()
+    expect(ingestDoc.ingestDocumentSchema.project_id).toBeDefined()
+    expect(ingestDoc.ingestDocumentSchema.body).toBeDefined()
+    expect(typeof ingestDoc.ingestDocument).toBe('function')
+
+    const sessions = await import('../tools/sessions.js')
+    expect(sessions.createSessionSchema).toBeDefined()
+    expect(sessions.closeSessionSchema).toBeDefined()
+    expect(sessions.listOpenSessionsSchema).toBeDefined()
+    expect(typeof sessions.createSession).toBe('function')
+    expect(typeof sessions.closeSession).toBe('function')
+    expect(typeof sessions.listOpenSessions).toBe('function')
+
+    const appendEntry = await import('../tools/append-session-entry.js')
+    expect(appendEntry.appendSessionEntrySchema).toBeDefined()
+    expect(typeof appendEntry.appendSessionEntry).toBe('function')
+
+    const letters = await import('../tools/letters.js')
+    expect(letters.createLetterSchema).toBeDefined()
+    expect(letters.replyLetterSchema).toBeDefined()
+    expect(typeof letters.createLetter).toBe('function')
+    expect(typeof letters.replyLetter).toBe('function')
+
+    const letterInbox = await import('../tools/letter-inbox.js')
+    expect(letterInbox.listInboxSchema).toBeDefined()
+    expect(letterInbox.listInboxSchema.project_id).toBeDefined()
+    expect(letterInbox.listOutboxSchema).toBeDefined()
+    expect(letterInbox.listOutboxSchema.project_id).toBeDefined()
+    expect(letterInbox.acknowledgeLetterSchema).toBeDefined()
+    expect(letterInbox.acknowledgeLetterSchema.letter_id).toBeDefined()
+    expect(typeof letterInbox.listInbox).toBe('function')
+    expect(typeof letterInbox.listOutbox).toBe('function')
+    expect(typeof letterInbox.acknowledgeLetter).toBe('function')
+
+    const comments = await import('../tools/decision-comments.js')
+    expect(comments.addDecisionCommentSchema).toBeDefined()
+    expect(comments.listDecisionCommentsSchema).toBeDefined()
+    expect(typeof comments.addDecisionComment).toBe('function')
+    expect(typeof comments.listDecisionComments).toBe('function')
+
+    const governance = await import('../tools/governance.js')
+    expect(governance.createAdrDraftSchema).toBeDefined()
+    expect(governance.submitAdrReviewSchema).toBeDefined()
+    expect(governance.recordAdrDecisionSchema).toBeDefined()
+    expect(typeof governance.createAdrDraft).toBe('function')
+    expect(typeof governance.submitAdrReview).toBe('function')
+    expect(typeof governance.recordAdrDecision).toBe('function')
+
+    const skills = await import('../tools/skills.js')
+    expect(skills.skListSchema).toBeDefined()
+    expect(skills.skGetSchema).toBeDefined()
+    expect(skills.skGetSchema.skill_id).toBeDefined()
+    expect(skills.skCreateSchema).toBeDefined()
+    expect(skills.skCreateSchema.skill_id).toBeDefined()
+    expect(skills.skCreateSchema.name).toBeDefined()
+    expect(skills.skCreateSchema.body).toBeDefined()
+    expect(skills.skUpdateSchema).toBeDefined()
+    expect(skills.skUpdateSchema.skill_id).toBeDefined()
+    expect(skills.skActivateSchema).toBeDefined()
+    expect(skills.skActivateSchema.skill_id).toBeDefined()
+    expect(skills.skActivateSchema.status).toBeDefined()
+    expect(typeof skills.skList).toBe('function')
+    expect(typeof skills.skGet).toBe('function')
+    expect(typeof skills.skCreate).toBe('function')
+    expect(typeof skills.skUpdate).toBe('function')
+    expect(typeof skills.skActivate).toBe('function')
+
+    // project-list module
+    const projectList = await import('../tools/project-list.js')
+    expect(projectList.projectListSchema).toBeDefined()
+    expect(typeof projectList.projectList).toBe('function')
+
+    // skill-assign module (sk_assign, sk_unassign, sk_export)
+    const skillAssign = await import('../tools/skill-assign.js')
+    expect(skillAssign.skAssignSchema).toBeDefined()
+    expect(skillAssign.skAssignSchema.project_id).toBeDefined()
+    expect(skillAssign.skAssignSchema.skill_id).toBeDefined()
+    expect(skillAssign.skUnassignSchema).toBeDefined()
+    expect(skillAssign.skUnassignSchema.project_id).toBeDefined()
+    expect(skillAssign.skExportSchema).toBeDefined()
+    expect(skillAssign.skExportSchema.project_id).toBeDefined()
+    expect(typeof skillAssign.skAssign).toBe('function')
+    expect(typeof skillAssign.skUnassign).toBe('function')
+    expect(typeof skillAssign.skExport).toBe('function')
+
+    // reviews module (rv_list, rv_get, rv_create, rv_decide, rv_comment)
+    const reviews = await import('../tools/reviews.js')
+    expect(reviews.rvListSchema).toBeDefined()
+    expect(reviews.rvGetSchema).toBeDefined()
+    expect(reviews.rvCreateSchema).toBeDefined()
+    expect(reviews.rvCreateSchema.entity_type).toBeDefined()
+    expect(reviews.rvCreateSchema.entity_id).toBeDefined()
+    expect(reviews.rvDecideSchema).toBeDefined()
+    expect(reviews.rvDecideSchema.review_id).toBeDefined()
+    expect(reviews.rvDecideSchema.transition).toBeDefined()
+    expect(reviews.rvCommentSchema).toBeDefined()
+    expect(reviews.rvCommentSchema.review_id).toBeDefined()
+    expect(reviews.rvCommentSchema.body).toBeDefined()
+    expect(typeof reviews.rvList).toBe('function')
+    expect(typeof reviews.rvGet).toBe('function')
+    expect(typeof reviews.rvCreate).toBe('function')
+    expect(typeof reviews.rvDecide).toBe('function')
+    expect(typeof reviews.rvComment).toBe('function')
+  })
+})

package/src/__tests__/setup.ts

@@ -0,0 +1,15 @@
+/**
+ * Global test setup for MCP server tests.
+ *
+ * Sets environment variables needed for the Nexus API client.
+ */
+
+import { vi } from 'vitest'
+
+// Mock environment variables for Nexus API client
+process.env.NEXUS_API_URL = 'https://test.nexus.example.com'
+process.env.NEXUS_PRIVATE_TOKEN =
+  'nxs_pat_test-token-for-unit-tests-1234567890abc'
+
+// Suppress console.error from MCP tools during tests
+vi.spyOn(console, 'error').mockImplementation(() => {})