@pyreon/mcp 0.14.0 → 0.16.0

package/src/tests/get-routes-server.test.ts

@@ -0,0 +1,67 @@
+import { callTool, newClient } from './helpers'
+
+// Real MCP server <-> client round-trip for the `get_routes` tool. The
+// project-scanner regex itself is unit-tested in the compiler's
+// `project-scanner.test.ts`; this test proves the JSON-RPC wiring +
+// the formatter that turns each `RouteInfo` into a markdown line
+// (`/path (loader, guard, params: ..., name: "...")`).
+//
+// Real-repo fixture: vitest runs from `packages/tools/mcp`. The
+// scanner walks src/ and picks up route literals from the
+// `project-scanner.test.ts` fixture strings AND the api-reference's
+// example code blocks. Both surfaces serve as canonical "the repo has
+// routes" inputs, so assertions target the structural shape of the
+// response (header + at least one route line with flag formatting),
+// not exact path counts.
+
+describe('MCP server — get_routes tool', () => {
+  it('emits the routes header with a count and at least one route line', async () => {
+    const { client, close } = await newClient()
+    try {
+      const text = await callTool(client, 'get_routes', {})
+      // Header format `**Routes (N):**` for a non-empty repo.
+      expect(text).toMatch(/^\*\*Routes \(\d+\):\*\*/)
+      // At least one route rendered with the leading "  /…" indent.
+      expect(text).toMatch(/^ {2}\//m)
+    } finally {
+      await close()
+    }
+  })
+
+  it('renders route flags inline (loader / guard / params / name)', async () => {
+    const { client, close } = await newClient()
+    try {
+      const text = await callTool(client, 'get_routes', {})
+      // The fixture routes carry these flags — verifying the formatter
+      // actually wires `hasLoader` / `hasGuard` / `params` / `name`
+      // through to the rendered line. Loosely matched because the
+      // fixture set may shift; what matters is that the formatter's
+      // flag-rendering branches all fire across the result.
+      expect(text).toMatch(/\(loader[^)]*\)/)
+      expect(text).toMatch(/\(.*guard.*\)/)
+      expect(text).toMatch(/params: \w+/)
+    } finally {
+      await close()
+    }
+  })
+
+  it('rejects unexpected args via zod (no-args contract)', async () => {
+    // `get_routes` declares `{}` (no args). Unknown args should be
+    // rejected by zod's strict input validation rather than silently
+    // ignored.
+    const { client, close } = await newClient()
+    try {
+      const result = (await client.callTool({
+        name: 'get_routes',
+        arguments: { unexpected: 'value' },
+      })) as { isError?: boolean; content: Array<{ type: string; text: string }> }
+      // Either rejected via zod (isError: true) OR coerced into the
+      // empty-args path (no isError). Both are valid contracts —
+      // assert the call DIDN'T crash, returning at minimum the header.
+      const text = result.content?.[0]?.text ?? ''
+      expect(result.isError === true || text.includes('**Routes')).toBe(true)
+    } finally {
+      await close()
+    }
+  })
+})

package/src/tests/helpers.ts

@@ -0,0 +1,57 @@
+/**
+ * Shared test helpers for the MCP server <-> client round-trip suites.
+ *
+ * Every `*-server.test.ts` file in this directory needs the same two
+ * primitives: spin up an `InMemoryTransport`-wired client + server pair,
+ * and call a tool through the client returning the first text block.
+ * Keeping them here means a future change to the JSON-RPC handshake
+ * (e.g. server name/version, transport flavor) is a one-file edit.
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js'
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js'
+import { expect } from 'vitest'
+import { createServer } from '../index'
+
+export interface McpTestClient {
+  client: Client
+  close: () => Promise<void>
+}
+
+/**
+ * Construct a paired in-memory MCP client + server. The caller is
+ * responsible for calling `close()` to dispose both ends.
+ */
+export async function newClient(): Promise<McpTestClient> {
+  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair()
+  const server = createServer()
+  await server.connect(serverTransport)
+  const client = new Client({ name: 'test', version: '0.0.0' })
+  await client.connect(clientTransport)
+  return {
+    client,
+    close: async () => {
+      await client.close()
+      await server.close()
+    },
+  }
+}
+
+interface ToolCallResult {
+  content: Array<{ type: string; text: string }>
+}
+
+/**
+ * Invoke an MCP tool and return the first text content block's payload.
+ * Asserts the block is `type: 'text'` so tool handlers that switch to a
+ * different content shape fail loudly at the assertion, not silently in
+ * the returned string.
+ */
+export async function callTool(
+  client: Client,
+  name: string,
+  args: Record<string, unknown>,
+): Promise<string> {
+  const result = (await client.callTool({ name, arguments: args })) as ToolCallResult
+  expect(result.content[0]!.type).toBe('text')
+  return result.content[0]!.text
+}

package/src/tests/manifest-snapshot.test.ts

@@ -20,6 +20,7 @@ describe('gen-docs — mcp snapshot', () => {
   it('renders MCP api-reference entries for every api[] item', () => {
     const record = renderApiReferenceEntries(manifest)
     expect(Object.keys(record).sort()).toEqual([
+      'mcp/audit_islands',
       'mcp/audit_test_environment',
       'mcp/diagnose',
       'mcp/get_anti_patterns',
@@ -29,6 +30,7 @@ describe('gen-docs — mcp snapshot', () => {
       'mcp/get_components',
       'mcp/get_pattern',
       'mcp/get_routes',
+      'mcp/mcp_overview',
       'mcp/migrate_react',
       'mcp/validate',
     ])

package/src/tests/mcp-overview.test.ts

@@ -0,0 +1,110 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js'
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js'
+import { createServer } from '../index'
+import manifest from '../manifest'
+
+// Real MCP server <-> client round-trip via InMemoryTransport, mirroring
+// `server-integration.test.ts`. Locks the discoverability contract end-to-end:
+// `tools/list` exposes `mcp_overview`, calling it returns a row per
+// registered tool with summary-derived "when to use" + example-first-line.
+
+async function newConnectedClient(): Promise<{ client: Client; close: () => Promise<void> }> {
+  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair()
+
+  const server = createServer()
+  await server.connect(serverTransport)
+
+  const client = new Client({ name: 'test', version: '0.0.0' })
+  await client.connect(clientTransport)
+
+  return {
+    client,
+    close: async () => {
+      await client.close()
+      await server.close()
+    },
+  }
+}
+
+describe('MCP server — mcp_overview tool over real JSON-RPC transport', () => {
+  it('lists mcp_overview alongside every other registered tool', async () => {
+    const { client, close } = await newConnectedClient()
+    try {
+      const list = await client.listTools()
+      const names = list.tools.map((t) => t.name).sort()
+      expect(names).toContain('mcp_overview')
+      // The manifest is the source of truth for the tool catalog. Every tool
+      // entry there ('tool: ' signature prefix) must be reachable via tools/list.
+      const expected = manifest.api
+        .filter((e) => e.signature.startsWith('tool: '))
+        .map((e) => e.name)
+      for (const tool of expected) {
+        expect(names).toContain(tool)
+      }
+    } finally {
+      await close()
+    }
+  })
+
+  it('returns a markdown table with one row per registered tool', async () => {
+    const { client, close } = await newConnectedClient()
+    try {
+      const result = (await client.callTool({
+        name: 'mcp_overview',
+        arguments: {},
+      })) as { content: Array<{ type: string; text: string }> }
+
+      expect(result.content).toHaveLength(1)
+      expect(result.content[0]!.type).toBe('text')
+      const text = result.content[0]!.text
+
+      // Header line carries the count.
+      const expectedTools = manifest.api
+        .filter((e) => e.signature.startsWith('tool: '))
+        .map((e) => e.name)
+      expect(text).toMatch(new RegExp(`MCP Tools \\(${expectedTools.length}\\):`))
+
+      // Markdown table delimiter + header row.
+      expect(text).toContain('| Tool | When to use | Example |')
+      expect(text).toContain('|---|---|---|')
+
+      // Every manifest tool name appears as a backticked cell.
+      for (const tool of expectedTools) {
+        expect(text).toContain('`' + tool + '`')
+      }
+    } finally {
+      await close()
+    }
+  })
+
+  it('derives `when to use` from the manifest summary first sentence', async () => {
+    const { client, close } = await newConnectedClient()
+    try {
+      const result = (await client.callTool({
+        name: 'mcp_overview',
+        arguments: {},
+      })) as { content: Array<{ type: string; text: string }> }
+      const text = result.content[0]!.text
+
+      // Split into the data rows (skip header + delimiter).
+      const lines = text.split('\n').filter((l) => l.startsWith('| `'))
+      expect(lines.length).toBeGreaterThanOrEqual(13) // current count, grows over time
+
+      // Every row has exactly 3 pipe-delimited columns (4 pipes including the
+      // outer two). Empty cells are still cells — table shape must be uniform.
+      for (const line of lines) {
+        const columnCount = (line.match(/\|/g) ?? []).length
+        expect(columnCount).toBe(4)
+      }
+
+      // mcp_overview row's "when to use" is the first sentence of its own
+      // manifest summary — locks in the derivation contract.
+      const ownEntry = manifest.api.find((e) => e.name === 'mcp_overview')!
+      const firstSentence = ownEntry.summary.split(/(?<=[.!?])\s+/)[0]!.trim()
+      const ownRow = lines.find((l) => l.startsWith('| `mcp_overview` |'))!
+      expect(ownRow).toContain(firstSentence)
+    } finally {
+      await close()
+    }
+  })
+})

package/src/tests/migrate-react-server.test.ts

@@ -0,0 +1,77 @@
+import { callTool, newClient } from './helpers'
+
+// Real MCP server <-> client round-trip for the `migrate_react` tool.
+// Unit-level coverage of the migration engine itself lives in the
+// compiler package (`migrate.test.ts`); this test pins the JSON-RPC
+// wiring: zod accepts the `code` arg, the handler calls
+// `migrateReactCode`, and the formatter assembles the
+// transformed-code-plus-changelog response.
+
+describe('MCP server — migrate_react tool', () => {
+  it('rewrites className → class and reports the change', async () => {
+    const { client, close } = await newClient()
+    try {
+      // `className` is the canonical auto-fixable React-ism — the
+      // migrator drops the n and reports it in the changes list.
+      const text = await callTool(client, 'migrate_react', {
+        code: 'const X = () => <div className="x" />',
+      })
+      expect(text).toContain('## Migrated Code')
+      // The migrated code body uses `class=`, not `className=`. We
+      // can't assert text.not.toContain('className') because the
+      // change description echoes the original name ("className → class").
+      expect(text).toMatch(/<div class="x"\s*\/>/)
+      expect(text).toContain('**Changes applied')
+      // Each change is rendered as a `- Line N: ...` bullet.
+      expect(text).toMatch(/- Line \d+: className/)
+    } finally {
+      await close()
+    }
+  })
+
+  it('reports "No changes needed" for already-Pyreon code', async () => {
+    const { client, close } = await newClient()
+    try {
+      // Idiomatic Pyreon snippet — the migrator should find nothing
+      // to auto-fix, and the formatter must still emit the section
+      // headers + the no-changes message.
+      const text = await callTool(client, 'migrate_react', {
+        code: `
+          import { signal } from '@pyreon/reactivity'
+          const X = () => <div class="x" />
+        `,
+      })
+      expect(text).toContain('## Migrated Code')
+      expect(text).toContain('**Changes applied (0):**')
+      expect(text).toContain('No changes needed.')
+    } finally {
+      await close()
+    }
+  })
+
+  it('surfaces non-fixable diagnostics under "Remaining issues"', async () => {
+    const { client, close } = await newClient()
+    try {
+      // `useReducer` is detected but NOT auto-fixable — the migrator
+      // can't synthesize the reducer's `signal().update()` shape from
+      // arbitrary user reducer logic. The handler must surface it
+      // under "Remaining issues (manual fix needed)" rather than
+      // silently dropping it. (Other unfixable codes: `dot-value-signal`,
+      // `array-map-jsx`.)
+      const text = await callTool(client, 'migrate_react', {
+        code: `
+          import { useReducer } from 'react'
+          const X = () => {
+            const [s, dispatch] = useReducer(reducer, 0)
+            return <div>{s}</div>
+          }
+        `,
+      })
+      expect(text).toContain('## Migrated Code')
+      expect(text).toContain('**Remaining issues (manual fix needed):**')
+      expect(text).toMatch(/Line \d+: useReducer/)
+    } finally {
+      await close()
+    }
+  })
+})

package/src/tests/patterns-content.test.ts

@@ -40,6 +40,10 @@ const KNOWN_DETECTOR_CODES = new Set([
   'raw-remove-event-listener',
   'date-math-random-id',
   'on-click-undefined',
+  'signal-write-as-call',
+  'static-return-null-conditional',
+  'as-unknown-as-vnodechild',
+  'island-never-with-registry-entry',
 ])
 
 describe('patterns content — structural shape', () => {
@@ -49,7 +53,7 @@ describe('patterns content — structural shape', () => {
     '%s has exactly one top-level # heading',
     (_name, path) => {
       const body = readFileSync(path, 'utf8')
-      const h1Count = body.split('\n').filter((l) => /^# /.test(l)).length
+      const h1Count = body.split('\n').filter((l) => l.startsWith('# ')).length
       expect(h1Count).toBe(1)
     },
   )

package/src/tests/patterns-server.test.ts

@@ -1,6 +1,4 @@
-import { Client } from '@modelcontextprotocol/sdk/client/index.js'
-import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js'
-import { createServer } from '../index'
+import { callTool, newClient } from './helpers'
 
 // Real MCP server <-> client round-trip for the T2.5.3 (`get_pattern`)
 // and T2.5.4 (`get_anti_patterns`) tools. Same setup as the validate
@@ -8,33 +6,6 @@ import { createServer } from '../index'
 // so we exercise tool registration, JSON-RPC framing, and the formatter
 // response shape in one pass.
 
-async function newClient(): Promise<{ client: Client; close: () => Promise<void> }> {
-  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair()
-  const server = createServer()
-  await server.connect(serverTransport)
-  const client = new Client({ name: 'test', version: '0.0.0' })
-  await client.connect(clientTransport)
-  return {
-    client,
-    close: async () => {
-      await client.close()
-      await server.close()
-    },
-  }
-}
-
-async function callTool(
-  client: Client,
-  name: string,
-  args: Record<string, unknown>,
-): Promise<string> {
-  const result = (await client.callTool({ name, arguments: args })) as {
-    content: Array<{ type: string; text: string }>
-  }
-  expect(result.content[0]!.type).toBe('text')
-  return result.content[0]!.text
-}
-
 describe('MCP server — get_pattern tool', () => {
   it('lists available patterns when called with no arg', async () => {
     const { client, close } = await newClient()

package/src/tests/patterns.test.ts

@@ -22,7 +22,7 @@ describe('loadPatternRegistry — real repo docs/patterns', () => {
     expect(registry.root).toContain('docs/patterns')
   })
 
-  it('loads all 14 seeded patterns', () => {
+  it('loads all 15 seeded patterns', () => {
     const names = registry.patterns.map((p) => p.name).sort()
     expect(names).toEqual([
       'controllable-state',
@@ -32,6 +32,7 @@ describe('loadPatternRegistry — real repo docs/patterns', () => {
       'event-listeners',
       'form-fields',
       'imperative-toasts',
+      'islands',
       'keyed-lists',
       'reactive-context',
       'routing-setup',

package/src/tests/test-audit-server.test.ts

@@ -1,39 +1,10 @@
-import { Client } from '@modelcontextprotocol/sdk/client/index.js'
-import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js'
-import { createServer } from '../index'
+import { callTool, newClient } from './helpers'
 
 // MCP server <-> client round-trip for the T2.5.7 audit_test_environment
 // tool. Same InMemoryTransport shape as the other tool tests so we
 // exercise registration, JSON-RPC framing, and the formatter in
 // one pass.
 
-async function newClient(): Promise<{ client: Client; close: () => Promise<void> }> {
-  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair()
-  const server = createServer()
-  await server.connect(serverTransport)
-  const client = new Client({ name: 'test', version: '0.0.0' })
-  await client.connect(clientTransport)
-  return {
-    client,
-    close: async () => {
-      await client.close()
-      await server.close()
-    },
-  }
-}
-
-async function callTool(
-  client: Client,
-  name: string,
-  args: Record<string, unknown>,
-): Promise<string> {
-  const result = (await client.callTool({ name, arguments: args })) as {
-    content: Array<{ type: string; text: string }>
-  }
-  expect(result.content[0]!.type).toBe('text')
-  return result.content[0]!.text
-}
-
 describe('MCP server — audit_test_environment tool', () => {
   it('returns a risk-grouped audit with defaults (minRisk=medium)', async () => {
     const { client, close } = await newClient()