@mpowr/nexus-mcp 0.5.0

package/src/__tests__/layer3-governance.test.ts

@@ -0,0 +1,205 @@
+/**
+ * Tests for Layer 3 Governance tools.
+ * 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'
+
+describe('Layer 3: ADR Governance tools', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  describe('createAdrDraft', () => {
+    it('should create an ADR draft with auto-incremented number', async () => {
+      vi.mocked(nexusPost).mockResolvedValue(
+        mockApiSuccess({
+          action: 'adr_create',
+          adr_id: TEST_IDS.adrId,
+          adr_number: '0006',
+          project_id: TEST_IDS.projectId,
+          title: 'New ADR',
+          status: 'draft',
+        }),
+      )
+
+      const { createAdrDraft } = await import('../tools/governance.js')
+      const result = await createAdrDraft({
+        project_id: TEST_IDS.projectId,
+        title: 'New ADR',
+        context: 'ADR context',
+        decision: 'ADR decision content',
+        user_id: TEST_IDS.userId,
+      })
+
+      expect(result.isError).toBeUndefined()
+      const parsed = parseToolResponse(result)
+      expect(parsed.action).toBe('adr_create')
+      expect(parsed.adr_number).toBe('0006')
+      expect(parsed.status).toBe('draft')
+    })
+
+    it('should return error on API failure', async () => {
+      vi.mocked(nexusPost).mockResolvedValue(mockApiError('Failed to create ADR draft'))
+
+      const { createAdrDraft } = await import('../tools/governance.js')
+      const result = await createAdrDraft({
+        project_id: TEST_IDS.projectId,
+        title: 'Fail',
+        context: 'Context',
+        decision: 'Decision',
+        user_id: TEST_IDS.userId,
+      })
+
+      expect(result.isError).toBe(true)
+    })
+  })
+
+  describe('submitAdrReview', () => {
+    it('should transition a draft ADR to under_review', async () => {
+      vi.mocked(nexusPost).mockResolvedValue(
+        mockApiSuccess({
+          action: 'adr_submit',
+          adr_id: TEST_IDS.adrId,
+          title: 'ADR to review',
+          new_state: 'under_review',
+        }),
+      )
+
+      const { submitAdrReview } = await import('../tools/governance.js')
+      const result = await submitAdrReview({
+        adr_id: TEST_IDS.adrId,
+        user_id: TEST_IDS.userId,
+      })
+
+      expect(result.isError).toBeUndefined()
+      const parsed = parseToolResponse(result)
+      expect(parsed.action).toBe('adr_submit')
+      expect(parsed.new_state).toBe('under_review')
+    })
+
+    it('should return error for non-draft ADR', async () => {
+      vi.mocked(nexusPost).mockResolvedValue(
+        mockApiError('ADR must be in draft state to submit for review', 409),
+      )
+
+      const { submitAdrReview } = await import('../tools/governance.js')
+      const result = await submitAdrReview({
+        adr_id: TEST_IDS.adrId,
+        user_id: TEST_IDS.userId,
+      })
+
+      expect(result.isError).toBe(true)
+    })
+
+    it('should return error if ADR not found', async () => {
+      vi.mocked(nexusPost).mockResolvedValue(mockApiError('ADR not found', 404))
+
+      const { submitAdrReview } = await import('../tools/governance.js')
+      const result = await submitAdrReview({
+        adr_id: TEST_IDS.adrId,
+        user_id: TEST_IDS.userId,
+      })
+
+      expect(result.isError).toBe(true)
+    })
+  })
+
+  describe('recordAdrDecision', () => {
+    it('should accept an ADR under review', async () => {
+      vi.mocked(nexusPost).mockResolvedValue(
+        mockApiSuccess({
+          action: 'adr_decide',
+          adr_id: TEST_IDS.adrId,
+          title: 'Test ADR',
+          decision: 'accepted',
+          new_state: 'accepted',
+        }),
+      )
+
+      const { recordAdrDecision } = await import('../tools/governance.js')
+      const result = await recordAdrDecision({
+        adr_id: TEST_IDS.adrId,
+        decision: 'accepted',
+        user_id: TEST_IDS.userId,
+      })
+
+      expect(result.isError).toBeUndefined()
+      const parsed = parseToolResponse(result)
+      expect(parsed.action).toBe('adr_decide')
+      expect(parsed.decision).toBe('accepted')
+      expect(parsed.new_state).toBe('accepted')
+    })
+
+    it('should reject an ADR under review', async () => {
+      vi.mocked(nexusPost).mockResolvedValue(
+        mockApiSuccess({
+          action: 'adr_decide',
+          adr_id: TEST_IDS.adrId,
+          title: 'Test ADR',
+          decision: 'rejected',
+          new_state: 'rejected',
+        }),
+      )
+
+      const { recordAdrDecision } = await import('../tools/governance.js')
+      const result = await recordAdrDecision({
+        adr_id: TEST_IDS.adrId,
+        decision: 'rejected',
+        rationale: 'Does not align with platform direction',
+        user_id: TEST_IDS.userId,
+      })
+
+      expect(result.isError).toBeUndefined()
+      const parsed = parseToolResponse(result)
+      expect(parsed.decision).toBe('rejected')
+    })
+
+    it('should include superseded_adr in response when accepting with supersedes', async () => {
+      const supersededId = '11111111-1111-1111-1111-111111111111'
+      vi.mocked(nexusPost).mockResolvedValue(
+        mockApiSuccess({
+          action: 'adr_decide',
+          adr_id: TEST_IDS.adrId,
+          title: 'Superseding ADR',
+          decision: 'accepted',
+          new_state: 'accepted',
+          superseded_adr: supersededId,
+        }),
+      )
+
+      const { recordAdrDecision } = await import('../tools/governance.js')
+      const result = await recordAdrDecision({
+        adr_id: TEST_IDS.adrId,
+        decision: 'accepted',
+        user_id: TEST_IDS.userId,
+      })
+
+      expect(result.isError).toBeUndefined()
+      const parsed = parseToolResponse(result)
+      expect(parsed.superseded_adr).toBe(supersededId)
+    })
+
+    it('should return error for non-review ADR', async () => {
+      vi.mocked(nexusPost).mockResolvedValue(
+        mockApiError('ADR must be under review to record a decision', 409),
+      )
+
+      const { recordAdrDecision } = await import('../tools/governance.js')
+      const result = await recordAdrDecision({
+        adr_id: TEST_IDS.adrId,
+        decision: 'accepted',
+        user_id: TEST_IDS.userId,
+      })
+
+      expect(result.isError).toBe(true)
+    })
+  })
+})

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

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