@gwdn/nexus-mcp 0.8.7 → 0.8.8

package/src/__tests__/project-list-and-skill-assign.test.ts

@@ -1,282 +0,0 @@
-/**
- * Tests for project_list, sk_assign, sk_unassign, and sk_export tools.
- *
- * project_list delegates to GET /api/mcp/projects via nexusGet().
- * sk_assign / sk_unassign / sk_export delegate to POST /api/mcp/skills via nexusPost().
- */
-
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { mockApiError, mockApiSuccess, parseToolResponse, TEST_IDS } from './helpers'
-
-vi.mock('../nexus-api.js', () => ({
-  nexusGet: vi.fn(),
-  nexusPost: vi.fn(),
-}))
-
-import { nexusGet, nexusPost } from '../nexus-api.js'
-
-// ---------------------------------------------------------------------------
-// project_list
-// ---------------------------------------------------------------------------
-
-describe('project_list', () => {
-  beforeEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  it('should return a list of projects', async () => {
-    vi.mocked(nexusGet).mockResolvedValue(
-      mockApiSuccess({
-        total: 2,
-        projects: [
-          { id: TEST_IDS.projectId, name: 'Project Alpha', slug: 'alpha' },
-          { id: '11111111-1111-1111-1111-111111111111', name: 'Project Beta', slug: 'beta' },
-        ],
-      }),
-    )
-
-    const { projectList } = await import('../tools/project-list.js')
-    const result = await projectList({})
-
-    expect(result.isError).toBeUndefined()
-    const parsed = parseToolResponse(result)
-    expect(parsed.total).toBe(2)
-    expect(parsed.projects).toHaveLength(2)
-    expect(parsed.projects[0].name).toBe('Project Alpha')
-  })
-
-  it('should return an empty list when no projects exist', async () => {
-    vi.mocked(nexusGet).mockResolvedValue(
-      mockApiSuccess({
-        total: 0,
-        projects: [],
-      }),
-    )
-
-    const { projectList } = await import('../tools/project-list.js')
-    const result = await projectList({})
-
-    expect(result.isError).toBeUndefined()
-    const parsed = parseToolResponse(result)
-    expect(parsed.total).toBe(0)
-    expect(parsed.projects).toHaveLength(0)
-  })
-
-  it('should handle API errors gracefully', async () => {
-    vi.mocked(nexusGet).mockResolvedValue(mockApiError('Unauthorized', 401))
-
-    const { projectList } = await import('../tools/project-list.js')
-    const result = await projectList({})
-
-    expect(result.isError).toBe(true)
-    const parsed = parseToolResponse(result)
-    expect(parsed.error).toBe('Unauthorized')
-  })
-})
-
-// ---------------------------------------------------------------------------
-// sk_assign
-// ---------------------------------------------------------------------------
-
-describe('sk_assign', () => {
-  beforeEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  it('should assign a skill to a project', async () => {
-    vi.mocked(nexusPost).mockResolvedValue(
-      mockApiSuccess({
-        action: 'sk_assign',
-        assignment_id: TEST_IDS.assignmentId,
-        project_id: TEST_IDS.projectId,
-        skill_id: TEST_IDS.skillId,
-        enabled: true,
-      }),
-    )
-
-    const { skAssign } = await import('../tools/skill-assign.js')
-    const result = await skAssign({
-      project_id: TEST_IDS.projectId,
-      skill_id: 'nx-init-nexus',
-      user_id: TEST_IDS.userId,
-    })
-
-    expect(result.isError).toBeUndefined()
-    const parsed = parseToolResponse(result)
-    expect(parsed.action).toBe('sk_assign')
-    expect(parsed.assignment_id).toBe(TEST_IDS.assignmentId)
-    expect(parsed.project_id).toBe(TEST_IDS.projectId)
-  })
-
-  it('should support pinned_version parameter', async () => {
-    vi.mocked(nexusPost).mockResolvedValue(
-      mockApiSuccess({
-        action: 'sk_assign',
-        assignment_id: TEST_IDS.assignmentId,
-        project_id: TEST_IDS.projectId,
-        skill_id: TEST_IDS.skillId,
-        pinned_version: 3,
-        enabled: true,
-      }),
-    )
-
-    const { skAssign } = await import('../tools/skill-assign.js')
-    const result = await skAssign({
-      project_id: TEST_IDS.projectId,
-      skill_id: 'nx-init-nexus',
-      pinned_version: 3,
-      user_id: TEST_IDS.userId,
-    })
-
-    expect(result.isError).toBeUndefined()
-    const parsed = parseToolResponse(result)
-    expect(parsed.pinned_version).toBe(3)
-  })
-
-  it('should return error on duplicate assignment (409)', async () => {
-    vi.mocked(nexusPost).mockResolvedValue(
-      mockApiError('Skill already assigned to this project', 409),
-    )
-
-    const { skAssign } = await import('../tools/skill-assign.js')
-    const result = await skAssign({
-      project_id: TEST_IDS.projectId,
-      skill_id: 'nx-init-nexus',
-      user_id: TEST_IDS.userId,
-    })
-
-    expect(result.isError).toBe(true)
-    const parsed = parseToolResponse(result)
-    expect(parsed.error).toBe('Skill already assigned to this project')
-  })
-
-  it('should return error on API failure', async () => {
-    vi.mocked(nexusPost).mockResolvedValue(mockApiError('Internal server error', 500))
-
-    const { skAssign } = await import('../tools/skill-assign.js')
-    const result = await skAssign({
-      project_id: TEST_IDS.projectId,
-      skill_id: 'nx-init-nexus',
-      user_id: TEST_IDS.userId,
-    })
-
-    expect(result.isError).toBe(true)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// sk_unassign
-// ---------------------------------------------------------------------------
-
-describe('sk_unassign', () => {
-  beforeEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  it('should unassign a skill from a project', async () => {
-    vi.mocked(nexusPost).mockResolvedValue(
-      mockApiSuccess({
-        action: 'sk_unassign',
-        project_id: TEST_IDS.projectId,
-        skill_id: TEST_IDS.skillId,
-        removed: true,
-      }),
-    )
-
-    const { skUnassign } = await import('../tools/skill-assign.js')
-    const result = await skUnassign({
-      project_id: TEST_IDS.projectId,
-      skill_id: 'nx-init-nexus',
-      user_id: TEST_IDS.userId,
-    })
-
-    expect(result.isError).toBeUndefined()
-    const parsed = parseToolResponse(result)
-    expect(parsed.action).toBe('sk_unassign')
-    expect(parsed.removed).toBe(true)
-  })
-
-  it('should return error on API failure', async () => {
-    vi.mocked(nexusPost).mockResolvedValue(mockApiError('Assignment not found', 404))
-
-    const { skUnassign } = await import('../tools/skill-assign.js')
-    const result = await skUnassign({
-      project_id: TEST_IDS.projectId,
-      skill_id: 'nx-nonexistent',
-      user_id: TEST_IDS.userId,
-    })
-
-    expect(result.isError).toBe(true)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// sk_export
-// ---------------------------------------------------------------------------
-
-describe('sk_export', () => {
-  beforeEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  it('should export skills assigned to a project', async () => {
-    vi.mocked(nexusPost).mockResolvedValue(
-      mockApiSuccess({
-        action: 'sk_export',
-        project_id: TEST_IDS.projectId,
-        count: 2,
-        skills: [
-          { skill_id: 'nx-init-nexus', name: 'Init Nexus', status: 'active', pinned_version: null },
-          { skill_id: 'nx-git-commit', name: 'Git Commit', status: 'active', pinned_version: 2 },
-        ],
-      }),
-    )
-
-    const { skExport } = await import('../tools/skill-assign.js')
-    const result = await skExport({
-      project_id: TEST_IDS.projectId,
-      user_id: TEST_IDS.userId,
-    })
-
-    expect(result.isError).toBeUndefined()
-    const parsed = parseToolResponse(result)
-    expect(parsed.action).toBe('sk_export')
-    expect(parsed.count).toBe(2)
-    expect(parsed.skills).toHaveLength(2)
-    expect(parsed.skills[0].skill_id).toBe('nx-init-nexus')
-  })
-
-  it('should return empty list for a project with no assigned skills', async () => {
-    vi.mocked(nexusPost).mockResolvedValue(
-      mockApiSuccess({
-        action: 'sk_export',
-        project_id: TEST_IDS.projectId,
-        count: 0,
-        skills: [],
-      }),
-    )
-
-    const { skExport } = await import('../tools/skill-assign.js')
-    const result = await skExport({
-      project_id: TEST_IDS.projectId,
-      user_id: TEST_IDS.userId,
-    })
-
-    expect(result.isError).toBeUndefined()
-    const parsed = parseToolResponse(result)
-    expect(parsed.count).toBe(0)
-    expect(parsed.skills).toHaveLength(0)
-  })
-
-  it('should return error on API failure', async () => {
-    vi.mocked(nexusPost).mockResolvedValue(mockApiError('Project not found', 404))
-
-    const { skExport } = await import('../tools/skill-assign.js')
-    const result = await skExport({
-      project_id: TEST_IDS.projectId,
-      user_id: TEST_IDS.userId,
-    })
-
-    expect(result.isError).toBe(true)
-  })
-})

package/src/__tests__/reviews.test.ts

@@ -1,420 +0,0 @@
-/**
- * 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)
-  })
-})