mirror of
https://github.com/abhigyanpatwari/GitNexus.git
synced 2026-10-28 06:22:22 +00:00
874 lines
37 KiB
TypeScript
874 lines
37 KiB
TypeScript
/**
|
|
* Unit Tests: MCP Server
|
|
*
|
|
* Tests: createMCPServer from server.ts
|
|
* - Server creation returns a Server instance
|
|
* - Tool handler wraps backend.callTool and appends hints
|
|
* - Tool handler catches errors and returns isError: true
|
|
* - Resource handlers delegate to resources.ts functions
|
|
* - Prompt handlers return expected prompts
|
|
* - Next-step hints cover all tool names
|
|
*
|
|
* NOTE: We test the server handler logic by calling the request handlers
|
|
* directly through the MCP Server's handler dispatch.
|
|
*/
|
|
import { describe, it, expect, vi } from 'vitest';
|
|
import { Client } from '@modelcontextprotocol/sdk/client/index.js';
|
|
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
|
|
import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
|
|
import { CallToolResultSchema } from '@modelcontextprotocol/sdk/types.js';
|
|
import {
|
|
createMCPServer,
|
|
getNextStepHint,
|
|
installSignalShutdown,
|
|
startMCPServer,
|
|
SHUTDOWN_EXIT_CODES,
|
|
} from '../../src/mcp/server.js';
|
|
import { GITNEXUS_TOOLS } from '../../src/mcp/tools.js';
|
|
import { createMcpRepositoryPolicy } from '../../src/mcp/repository-policy.js';
|
|
|
|
// ─── Mock backend ──────────────────────────────────────────────────
|
|
|
|
function createMockBackend(overrides: Record<string, any> = {}): any {
|
|
return {
|
|
callTool: vi.fn().mockResolvedValue({ result: 'ok' }),
|
|
listRepos: vi.fn().mockResolvedValue([]),
|
|
countRepos: vi.fn().mockResolvedValue(0),
|
|
cachedRepoCount: vi.fn().mockReturnValue(0),
|
|
resolveRepo: vi
|
|
.fn()
|
|
.mockResolvedValue({ name: 'test', repoPath: '/tmp/test', lastCommit: 'abc' }),
|
|
selectToolRepository: vi
|
|
.fn()
|
|
.mockResolvedValue({ name: 'test', repoPath: '/tmp/test', lastCommit: 'abc' }),
|
|
getContext: vi.fn().mockReturnValue(null),
|
|
queryClusters: vi.fn().mockResolvedValue({ clusters: [] }),
|
|
queryProcesses: vi.fn().mockResolvedValue({ processes: [] }),
|
|
queryClusterDetail: vi.fn().mockResolvedValue({ error: 'not found' }),
|
|
queryProcessDetail: vi.fn().mockResolvedValue({ error: 'not found' }),
|
|
disconnect: vi.fn().mockResolvedValue(undefined),
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
async function callToolThroughServer(
|
|
backend: ReturnType<typeof createMockBackend>,
|
|
name: string,
|
|
args: Record<string, unknown>,
|
|
): Promise<{ text: string; isError: boolean }> {
|
|
const server = createMCPServer(backend);
|
|
const client = new Client({ name: 'budget-test-client', version: '0.0.0' });
|
|
const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
|
|
|
|
try {
|
|
await Promise.all([server.connect(serverTransport), client.connect(clientTransport)]);
|
|
const response = CallToolResultSchema.parse(await client.callTool({ name, arguments: args }));
|
|
const text = response.content.find((item) => item.type === 'text')?.text;
|
|
if (typeof text !== 'string') throw new Error('Expected an MCP text response');
|
|
return { text, isError: response.isError === true };
|
|
} finally {
|
|
await client.close();
|
|
await server.close();
|
|
}
|
|
}
|
|
|
|
// ─── createMCPServer ─────────────────────────────────────────────────
|
|
|
|
describe('createMCPServer', () => {
|
|
it('returns a Server instance with expected shape', () => {
|
|
const backend = createMockBackend();
|
|
const server = createMCPServer(backend);
|
|
expect(server).toBeDefined();
|
|
// Server should have connect/close methods
|
|
expect(typeof server.connect).toBe('function');
|
|
expect(typeof server.close).toBe('function');
|
|
});
|
|
|
|
it('server has setRequestHandler method', () => {
|
|
const backend = createMockBackend();
|
|
const server = createMCPServer(backend);
|
|
// The server has registered handlers — verify it was created without errors
|
|
expect(server).toBeTruthy();
|
|
});
|
|
|
|
it('tools/list response includes tool annotations', async () => {
|
|
const backend = createMockBackend();
|
|
const server = createMCPServer(backend);
|
|
const client = new Client({ name: 'test-client', version: '0.0.0' });
|
|
const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
|
|
|
|
try {
|
|
await Promise.all([server.connect(serverTransport), client.connect(clientTransport)]);
|
|
|
|
const response = await client.listTools();
|
|
expect(response.tools).toHaveLength(GITNEXUS_TOOLS.length);
|
|
|
|
for (const tool of response.tools) {
|
|
const definition = GITNEXUS_TOOLS.find((t) => t.name === tool.name)!;
|
|
expect(tool.annotations).toEqual(definition.annotations);
|
|
}
|
|
} finally {
|
|
await client.close();
|
|
await server.close();
|
|
}
|
|
});
|
|
it('requires repo in repo-scoped tool schemas when cwd cannot resolve multiple repos', async () => {
|
|
const backend = createMockBackend({
|
|
countRepos: vi.fn().mockResolvedValue(2),
|
|
listRepos: vi.fn().mockResolvedValue([
|
|
{ name: 'alpha', path: '/tmp/alpha' },
|
|
{ name: 'beta', path: '/tmp/beta' },
|
|
]),
|
|
selectToolRepository: vi.fn().mockRejectedValue(new Error('Multiple repositories indexed')),
|
|
});
|
|
const server = createMCPServer(backend);
|
|
const client = new Client({ name: 'multi-repo-client', version: '0.0.0' });
|
|
const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
|
|
|
|
try {
|
|
await Promise.all([server.connect(serverTransport), client.connect(clientTransport)]);
|
|
const tools = await client.listTools();
|
|
const query = tools.tools.find((tool) => tool.name === 'query');
|
|
const listRepos = tools.tools.find((tool) => tool.name === 'list_repos');
|
|
|
|
expect(query?.inputSchema.required).toContain('repo');
|
|
expect(listRepos?.inputSchema.required).not.toContain('repo');
|
|
for (const name of ['read_file', 'grep'] as const) {
|
|
const tool = tools.tools.find((candidate) => candidate.name === name);
|
|
expect(tool?.inputSchema.required, name).toContain('repo');
|
|
expect(tool?.inputSchema.properties, name).not.toHaveProperty('branch');
|
|
}
|
|
expect(
|
|
GITNEXUS_TOOLS.find((tool) => tool.name === 'query')?.inputSchema.required,
|
|
).not.toContain('repo');
|
|
} finally {
|
|
await client.close();
|
|
await server.close();
|
|
}
|
|
});
|
|
|
|
it('keeps repo optional when cwd resolves one of multiple visible repos', async () => {
|
|
const backend = createMockBackend({
|
|
countRepos: vi.fn().mockResolvedValue(2),
|
|
cachedRepoCount: vi.fn().mockReturnValue(2),
|
|
listRepos: vi.fn().mockResolvedValue([
|
|
{ name: 'alpha', path: '/tmp/alpha' },
|
|
{ name: 'beta', path: '/tmp/beta' },
|
|
]),
|
|
selectToolRepository: vi
|
|
.fn()
|
|
.mockResolvedValue({ name: 'alpha', repoPath: '/tmp/alpha', lastCommit: 'abc' }),
|
|
});
|
|
const server = createMCPServer(backend);
|
|
const client = new Client({ name: 'cwd-repo-client', version: '0.0.0' });
|
|
const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
|
|
|
|
try {
|
|
await Promise.all([server.connect(serverTransport), client.connect(clientTransport)]);
|
|
const tools = await client.listTools();
|
|
const context = tools.tools.find((tool) => tool.name === 'context');
|
|
const rename = tools.tools.find((tool) => tool.name === 'rename');
|
|
|
|
expect(context?.inputSchema.required).not.toContain('repo');
|
|
expect(rename?.inputSchema.required).toContain('repo');
|
|
const response = await client.callTool({ name: 'context', arguments: { name: 'Example' } });
|
|
expect(response.isError).not.toBe(true);
|
|
expect(backend.callTool).toHaveBeenCalledWith('context', { name: 'Example' });
|
|
expect(backend.countRepos).toHaveBeenCalledTimes(1);
|
|
expect(backend.listRepos).not.toHaveBeenCalled();
|
|
expect(backend.selectToolRepository).toHaveBeenCalledTimes(1);
|
|
expect(backend.selectToolRepository).toHaveBeenCalledWith(undefined, undefined, {
|
|
allowCwdDefault: true,
|
|
refreshRegistry: true,
|
|
});
|
|
} finally {
|
|
await client.close();
|
|
await server.close();
|
|
}
|
|
});
|
|
|
|
it('keeps repo optional when a default repo is configured', async () => {
|
|
const backend = createMockBackend({
|
|
listRepos: vi.fn().mockResolvedValue([
|
|
{ name: 'alpha', path: '/tmp/alpha' },
|
|
{ name: 'beta', path: '/tmp/beta' },
|
|
]),
|
|
});
|
|
const repositoryPolicy = await createMcpRepositoryPolicy(backend, {
|
|
GITNEXUS_MCP_DEFAULT_REPO: 'alpha',
|
|
});
|
|
const server = createMCPServer(backend, { repositoryPolicy });
|
|
const client = new Client({ name: 'default-repo-client', version: '0.0.0' });
|
|
const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
|
|
|
|
try {
|
|
await Promise.all([server.connect(serverTransport), client.connect(clientTransport)]);
|
|
const tools = await client.listTools();
|
|
const query = tools.tools.find((tool) => tool.name === 'query');
|
|
|
|
expect(query?.inputSchema.required).not.toContain('repo');
|
|
} finally {
|
|
await client.close();
|
|
await server.close();
|
|
}
|
|
});
|
|
|
|
it('requires repo when multiple allowed repositories are visible without a default', async () => {
|
|
const backend = createMockBackend({
|
|
listRepos: vi.fn().mockResolvedValue([
|
|
{ name: 'alpha', path: '/tmp/alpha' },
|
|
{ name: 'beta', path: '/tmp/beta' },
|
|
{ name: 'gamma', path: '/tmp/gamma' },
|
|
]),
|
|
});
|
|
const repositoryPolicy = await createMcpRepositoryPolicy(backend, {
|
|
GITNEXUS_MCP_ALLOWED_REPOS: 'alpha,beta',
|
|
});
|
|
const server = createMCPServer(backend, { repositoryPolicy });
|
|
const client = new Client({ name: 'allowlisted-repos-client', version: '0.0.0' });
|
|
const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
|
|
|
|
try {
|
|
await Promise.all([server.connect(serverTransport), client.connect(clientTransport)]);
|
|
const tools = await client.listTools();
|
|
const query = tools.tools.find((tool) => tool.name === 'query');
|
|
|
|
expect(query?.inputSchema.required).toContain('repo');
|
|
} finally {
|
|
await client.close();
|
|
await server.close();
|
|
}
|
|
});
|
|
});
|
|
|
|
// ─── getNextStepHint (tested indirectly via server tool handler) ──────
|
|
|
|
describe('getNextStepHint (via tool call response)', () => {
|
|
// We test hints by calling the server's tool handler indirectly.
|
|
// Since createMCPServer registers handlers on the Server, we verify
|
|
// hints are appended by checking the tool response format.
|
|
|
|
it('query tool response includes hint about context', async () => {
|
|
const backend = createMockBackend({
|
|
callTool: vi.fn().mockResolvedValue({ processes: [], definitions: [] }),
|
|
});
|
|
const server = createMCPServer(backend);
|
|
|
|
// We can't easily call handlers directly on the MCP Server,
|
|
// so we verify the handler was registered by creating the server without error.
|
|
// The actual hint logic is tested via the integration path.
|
|
expect(backend.callTool).not.toHaveBeenCalled(); // not called until request
|
|
});
|
|
|
|
const QUERY_HINT_BASE =
|
|
'\n\n---\n**Next:** To understand a specific symbol in depth, use context({name: "<symbol_name>", repo: "demo"}) to see categorized refs and process participation.';
|
|
|
|
it('query hint is unchanged when include_content is not set', async () => {
|
|
const backend = createMockBackend({
|
|
callTool: vi.fn().mockResolvedValue({ processes: [] }),
|
|
});
|
|
const { text } = await callToolThroughServer(backend, 'query', {
|
|
search_query: 'auth',
|
|
repo: 'demo',
|
|
});
|
|
expect(text.endsWith(QUERY_HINT_BASE)).toBe(true);
|
|
expect(text).not.toContain('context({uid:');
|
|
});
|
|
|
|
it('query hint names the context({uid, include_content}) fallback when include_content is true', async () => {
|
|
const backend = createMockBackend({
|
|
callTool: vi.fn().mockResolvedValue({ processes: [] }),
|
|
});
|
|
const { text } = await callToolThroughServer(backend, 'query', {
|
|
search_query: 'auth',
|
|
repo: 'demo',
|
|
include_content: true,
|
|
});
|
|
expect(
|
|
text.endsWith(
|
|
`${QUERY_HINT_BASE} For source of a process_symbols row without content, use context({uid: "<id>", include_content: true, repo: "demo"}).`,
|
|
),
|
|
).toBe(true);
|
|
});
|
|
|
|
it('grep hint converts the 1-based hit line to a 0-based read_file window', async () => {
|
|
const backend = createMockBackend({
|
|
callTool: vi
|
|
.fn()
|
|
.mockResolvedValue({ results: [{ filePath: 'a.ts', line: 1, text: 'signOrder()' }] }),
|
|
});
|
|
const { text } = await callToolThroughServer(backend, 'grep', {
|
|
pattern: 'signOrder',
|
|
repo: 'demo',
|
|
});
|
|
expect(text).toContain('startLine: <hit.line - 1>');
|
|
expect(text).toContain('endLine: <hit.line - 1>');
|
|
expect(text).toContain('Grep line is 1-based; read_file is 0-based');
|
|
});
|
|
});
|
|
|
|
describe('getNextStepHint rename', () => {
|
|
const apply =
|
|
'rename({symbol_uid: "Method:src/a.ts:A.run#0", new_name: "go", dry_run: false, plan_token: "<plan_token from this preview>", repo: "demo"})';
|
|
|
|
it.each([
|
|
['omitted', { symbol_uid: 'Method:src/a.ts:A.run#0', new_name: 'go', repo: 'demo' }],
|
|
[
|
|
'true',
|
|
{ symbol_uid: 'Method:src/a.ts:A.run#0', new_name: 'go', repo: 'demo', dry_run: true },
|
|
],
|
|
])('points a dry run (dry_run %s) at the apply call, not at detect_changes', (_label, args) => {
|
|
const hint = getNextStepHint('rename', args);
|
|
expect(hint).toContain(apply);
|
|
expect(hint).toContain('no files were changed');
|
|
expect(hint).not.toContain('detect_changes');
|
|
});
|
|
|
|
it('shows the detect_changes hint only after an explicit dry_run:false', () => {
|
|
const hint = getNextStepHint(
|
|
'rename',
|
|
{ new_name: 'go', repo: 'demo', dry_run: false },
|
|
false,
|
|
{ status: 'success', applied: true, application_status: 'applied' },
|
|
);
|
|
expect(hint).toContain('detect_changes({repo: "demo"})');
|
|
expect(hint).not.toContain('dry_run: false');
|
|
});
|
|
|
|
it.each([
|
|
['the string "false"', 'false'],
|
|
['null', null],
|
|
['zero', 0],
|
|
])('does not treat dry_run %s as an applied rename', (_label, dryRun) => {
|
|
const hint = getNextStepHint('rename', { new_name: 'go', dry_run: dryRun });
|
|
expect(hint).not.toContain('detect_changes');
|
|
});
|
|
|
|
it('names symbol_name, quoted, when no symbol_uid was sent and omits repo when absent', () => {
|
|
const hint = getNextStepHint('rename', { symbol_name: 'run "fast"', new_name: 'go' });
|
|
expect(hint).toContain(
|
|
'rename({symbol_name: "run \\"fast\\"", new_name: "go", dry_run: false, plan_token: "<plan_token from this preview>"})',
|
|
);
|
|
});
|
|
|
|
it('never suggests applying from a read-only server', () => {
|
|
const hint = getNextStepHint('rename', { new_name: 'go', dry_run: true }, true);
|
|
expect(hint).toContain('MCP read-only mode cannot apply it');
|
|
expect(hint).toContain('fresh preview from a server that permits writes');
|
|
expect(hint).toContain("that server's plan_token");
|
|
expect(hint).not.toContain('dry_run: false');
|
|
expect(hint).not.toContain('detect_changes');
|
|
});
|
|
it.each(['plan_required', 'invalid_plan', 'plan_mismatch', 'source_changed'])(
|
|
'requests a fresh preview when apply fails with %s',
|
|
(code) => {
|
|
const hint = getNextStepHint('rename', { dry_run: false }, false, {
|
|
status: 'error',
|
|
applied: false,
|
|
code,
|
|
});
|
|
expect(hint).toContain('fresh rename preview');
|
|
expect(hint).toContain('plan_token');
|
|
expect(hint).not.toContain('detect_changes');
|
|
},
|
|
);
|
|
it('directs partial operations to reconcile exact write lists before retrying', () => {
|
|
const hint = getNextStepHint('rename', { dry_run: false }, false, {
|
|
status: 'partial',
|
|
applied: true,
|
|
application_status: 'partial',
|
|
});
|
|
expect(hint).toContain('failed_files and unattempted_files');
|
|
expect(hint).not.toContain('detect_changes');
|
|
});
|
|
});
|
|
|
|
describe('MCP output budgets', () => {
|
|
it('leaves the complete formatted response unchanged when no budget is configured', async () => {
|
|
const previous = process.env.GITNEXUS_MCP_DEFAULT_MAX_TOKENS;
|
|
delete process.env.GITNEXUS_MCP_DEFAULT_MAX_TOKENS;
|
|
try {
|
|
const backend = createMockBackend({
|
|
callTool: vi.fn().mockResolvedValue({ payload: 'complete' }),
|
|
});
|
|
const { text, isError } = await callToolThroughServer(backend, 'query', {
|
|
search_query: 'auth',
|
|
});
|
|
expect(isError).toBe(false);
|
|
expect(text).toContain('"payload":"complete"');
|
|
expect(text).toContain('**Next:**');
|
|
expect(text.endsWith('\n…')).toBe(false);
|
|
} finally {
|
|
if (previous === undefined) delete process.env.GITNEXUS_MCP_DEFAULT_MAX_TOKENS;
|
|
else process.env.GITNEXUS_MCP_DEFAULT_MAX_TOKENS = previous;
|
|
}
|
|
});
|
|
|
|
it('applies explicit maxTokens to the complete response deterministically and UTF-8 safely', async () => {
|
|
const backend = createMockBackend({
|
|
callTool: vi.fn().mockResolvedValue({ payload: '😀'.repeat(100) }),
|
|
});
|
|
const args = { search_query: 'auth', maxTokens: 8 };
|
|
|
|
const first = await callToolThroughServer(backend, 'query', args);
|
|
const second = await callToolThroughServer(backend, 'query', args);
|
|
|
|
expect(first.isError).toBe(false);
|
|
expect(first.text).toBe(second.text);
|
|
expect(Buffer.byteLength(first.text, 'utf8')).toBeLessThanOrEqual(8 * 4);
|
|
expect(first.text.endsWith('\n…')).toBe(true);
|
|
expect(first.text).not.toContain('\uFFFD');
|
|
expect(backend.callTool).toHaveBeenCalledWith('query', { search_query: 'auth' });
|
|
});
|
|
|
|
it('uses the environment default when maxTokens is omitted', async () => {
|
|
const previous = process.env.GITNEXUS_MCP_DEFAULT_MAX_TOKENS;
|
|
process.env.GITNEXUS_MCP_DEFAULT_MAX_TOKENS = '8';
|
|
try {
|
|
const backend = createMockBackend({
|
|
callTool: vi.fn().mockResolvedValue({ payload: 'x'.repeat(200) }),
|
|
});
|
|
const { text } = await callToolThroughServer(backend, 'context', { name: 'auth' });
|
|
expect(Buffer.byteLength(text, 'utf8')).toBeLessThanOrEqual(8 * 4);
|
|
expect(text.endsWith('\n…')).toBe(true);
|
|
} finally {
|
|
if (previous === undefined) delete process.env.GITNEXUS_MCP_DEFAULT_MAX_TOKENS;
|
|
else process.env.GITNEXUS_MCP_DEFAULT_MAX_TOKENS = previous;
|
|
}
|
|
});
|
|
|
|
it('lets an explicit request override the environment default', async () => {
|
|
const previous = process.env.GITNEXUS_MCP_DEFAULT_MAX_TOKENS;
|
|
process.env.GITNEXUS_MCP_DEFAULT_MAX_TOKENS = '1';
|
|
try {
|
|
const backend = createMockBackend({
|
|
callTool: vi.fn().mockResolvedValue({ payload: 'complete' }),
|
|
});
|
|
const { text } = await callToolThroughServer(backend, 'impact', {
|
|
target: 'auth',
|
|
direction: 'upstream',
|
|
maxTokens: 200,
|
|
});
|
|
expect(text).toContain('"payload":"complete"');
|
|
expect(text).toContain('**Next:**');
|
|
expect(text.endsWith('\n…')).toBe(false);
|
|
} finally {
|
|
if (previous === undefined) delete process.env.GITNEXUS_MCP_DEFAULT_MAX_TOKENS;
|
|
else process.env.GITNEXUS_MCP_DEFAULT_MAX_TOKENS = previous;
|
|
}
|
|
});
|
|
|
|
it('rejects unknown tool arguments before backend execution (#3261)', async () => {
|
|
const backend = createMockBackend();
|
|
const { text, isError } = await callToolThroughServer(backend, 'impact', {
|
|
target: 'auth',
|
|
direction: 'downstream',
|
|
notARealArg: 2,
|
|
});
|
|
expect(isError).toBe(true);
|
|
expect(text).toMatch(/Unknown argument "notARealArg" for tool "impact"/);
|
|
expect(backend.callTool).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('accepts CLI-style depth as a known impact alias (#3261)', async () => {
|
|
// The CLI flag is --depth; since #3261 MCP advertises it alongside maxDepth
|
|
// as a compatibility alias. Before #3261, `depth` was silently dropped.
|
|
// After the fix it is a known alias and is forwarded.
|
|
const backend = createMockBackend();
|
|
const { isError } = await callToolThroughServer(backend, 'impact', {
|
|
target: 'auth',
|
|
direction: 'downstream',
|
|
depth: 2,
|
|
});
|
|
expect(isError).toBe(false);
|
|
expect(backend.callTool).toHaveBeenCalledWith('impact', {
|
|
target: 'auth',
|
|
direction: 'downstream',
|
|
depth: 2,
|
|
});
|
|
});
|
|
|
|
it('still accepts unpublished context target through tools/call', async () => {
|
|
const backend = createMockBackend();
|
|
const { isError } = await callToolThroughServer(backend, 'context', {
|
|
repo: '@g1',
|
|
target: 'Sym',
|
|
});
|
|
expect(isError).toBe(false);
|
|
expect(backend.callTool).toHaveBeenCalledWith('context', { repo: '@g1', target: 'Sym' });
|
|
});
|
|
|
|
it('still accepts the unpublished query alias for query (#2175)', async () => {
|
|
const backend = createMockBackend();
|
|
const { isError } = await callToolThroughServer(backend, 'query', {
|
|
query: 'auth',
|
|
});
|
|
expect(isError).toBe(false);
|
|
expect(backend.callTool).toHaveBeenCalledWith('query', { query: 'auth' });
|
|
});
|
|
|
|
it('still accepts the unpublished query alias for cypher (#2175)', async () => {
|
|
const backend = createMockBackend();
|
|
const { isError } = await callToolThroughServer(backend, 'cypher', {
|
|
query: 'MATCH (n) RETURN n',
|
|
});
|
|
expect(isError).toBe(false);
|
|
expect(backend.callTool).toHaveBeenCalledWith('cypher', { query: 'MATCH (n) RETURN n' });
|
|
});
|
|
|
|
it('maps legacy search/explore names through the advertised schema (#3261)', async () => {
|
|
const backend = createMockBackend();
|
|
const searchUnknown = await callToolThroughServer(backend, 'search', { notARealArg: 1 });
|
|
expect(searchUnknown.isError).toBe(true);
|
|
expect(searchUnknown.text).toMatch(/Unknown argument "notARealArg"/);
|
|
expect(backend.callTool).not.toHaveBeenCalled();
|
|
|
|
const searchOk = await callToolThroughServer(backend, 'search', { query: 'auth' });
|
|
expect(searchOk.isError).toBe(false);
|
|
expect(backend.callTool).toHaveBeenCalledWith('search', { query: 'auth' });
|
|
|
|
backend.callTool.mockClear();
|
|
const exploreUnknown = await callToolThroughServer(backend, 'explore', { notARealArg: 1 });
|
|
expect(exploreUnknown.isError).toBe(true);
|
|
expect(backend.callTool).not.toHaveBeenCalled();
|
|
|
|
const exploreOk = await callToolThroughServer(backend, 'explore', {
|
|
repo: '@g1',
|
|
target: 'Sym',
|
|
});
|
|
expect(exploreOk.isError).toBe(false);
|
|
expect(backend.callTool).toHaveBeenCalledWith('explore', { repo: '@g1', target: 'Sym' });
|
|
});
|
|
|
|
it('rejects a non-positive explicit maxTokens before backend execution', async () => {
|
|
const backend = createMockBackend();
|
|
const { text, isError } = await callToolThroughServer(backend, 'query', {
|
|
search_query: 'auth',
|
|
maxTokens: 0,
|
|
});
|
|
expect(isError).toBe(true);
|
|
expect(text).toMatch(/maxTokens.*positive integer/i);
|
|
expect(backend.callTool).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('rejects an invalid environment default before backend execution', async () => {
|
|
const previous = process.env.GITNEXUS_MCP_DEFAULT_MAX_TOKENS;
|
|
process.env.GITNEXUS_MCP_DEFAULT_MAX_TOKENS = 'invalid';
|
|
try {
|
|
const backend = createMockBackend();
|
|
const { text, isError } = await callToolThroughServer(backend, 'query', {
|
|
search_query: 'auth',
|
|
});
|
|
expect(isError).toBe(true);
|
|
expect(text).toMatch(/GITNEXUS_MCP_DEFAULT_MAX_TOKENS.*positive integer/i);
|
|
expect(backend.callTool).not.toHaveBeenCalled();
|
|
} finally {
|
|
if (previous === undefined) delete process.env.GITNEXUS_MCP_DEFAULT_MAX_TOKENS;
|
|
else process.env.GITNEXUS_MCP_DEFAULT_MAX_TOKENS = previous;
|
|
}
|
|
});
|
|
|
|
it('applies a valid budget to backend error text', async () => {
|
|
const backend = createMockBackend({
|
|
callTool: vi.fn().mockRejectedValue(new Error('😀'.repeat(100))),
|
|
});
|
|
const { text, isError } = await callToolThroughServer(backend, 'context', {
|
|
name: 'auth',
|
|
maxTokens: 8,
|
|
});
|
|
expect(isError).toBe(true);
|
|
expect(Buffer.byteLength(text, 'utf8')).toBeLessThanOrEqual(8 * 4);
|
|
expect(text.endsWith('\n…')).toBe(true);
|
|
expect(text).not.toContain('\uFFFD');
|
|
});
|
|
});
|
|
|
|
// ─── Tool handler error handling ──────────────────────────────────────
|
|
|
|
describe('server error handling', () => {
|
|
it('includes string Error.code in tool error text', async () => {
|
|
const err = Object.assign(new Error('reader refuse'), { code: 'FTS_READER_UNREPAIRABLE' });
|
|
const backend = createMockBackend({
|
|
callTool: vi.fn().mockRejectedValue(err),
|
|
});
|
|
const { text, isError } = await callToolThroughServer(backend, 'context', { name: 'auth' });
|
|
expect(isError).toBe(true);
|
|
expect(text).toContain('FTS_READER_UNREPAIRABLE');
|
|
expect(text).toContain('reader refuse');
|
|
});
|
|
|
|
it('createMCPServer does not throw for valid backend', () => {
|
|
const backend = createMockBackend();
|
|
expect(() => createMCPServer(backend)).not.toThrow();
|
|
});
|
|
|
|
it('createMCPServer reads version from package.json', () => {
|
|
const backend = createMockBackend();
|
|
const server = createMCPServer(backend);
|
|
// Server was created with version from package.json — no crash
|
|
expect(server).toBeDefined();
|
|
});
|
|
});
|
|
|
|
// ─── Prompt definitions ───────────────────────────────────────────────
|
|
|
|
describe('prompt registration', () => {
|
|
it('server registers detect_impact and generate_map prompts', () => {
|
|
const backend = createMockBackend();
|
|
// Creating the server registers all handlers including prompts
|
|
const server = createMCPServer(backend);
|
|
expect(server).toBeDefined();
|
|
});
|
|
});
|
|
|
|
// ─── startMCPServer ────────────────────────────────────────────────────
|
|
|
|
describe('startMCPServer', () => {
|
|
it('registers stdin shutdown listeners before awaiting Server.prototype.connect', async () => {
|
|
// P1 finding: startMCPServer must register process.stdin end/close/error
|
|
// shutdown listeners before calling server.connect(), so that a stdin
|
|
// closure during transport setup is safely handled.
|
|
// This test asserts the listeners are present *during* the connect call.
|
|
|
|
// Capture baseline listener counts before startMCPServer adds anything
|
|
const closeBefore = process.stdin.listenerCount('close');
|
|
const endBefore = process.stdin.listenerCount('end');
|
|
const errorBefore = process.stdin.listenerCount('error');
|
|
const beforeListeners = {
|
|
stdinEnd: new Set(process.stdin.listeners('end')),
|
|
stdinClose: new Set(process.stdin.listeners('close')),
|
|
stdinError: new Set(process.stdin.listeners('error')),
|
|
stdoutError: new Set(process.stdout.listeners('error')),
|
|
sigint: new Set(process.listeners('SIGINT')),
|
|
sigterm: new Set(process.listeners('SIGTERM')),
|
|
exit: new Set(process.listeners('exit')),
|
|
uncaughtException: new Set(process.listeners('uncaughtException')),
|
|
unhandledRejection: new Set(process.listeners('unhandledRejection')),
|
|
};
|
|
|
|
// Stub process.exit to prevent actual termination if shutdown fires
|
|
const exitStub = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
|
|
|
|
// Spy on Server.prototype.connect to inspect listener counts during the call
|
|
const connectSpy = vi.spyOn(Server.prototype, 'connect').mockImplementation(async function () {
|
|
expect(process.stdin.listenerCount('close')).toBeGreaterThan(closeBefore);
|
|
expect(process.stdin.listenerCount('end')).toBeGreaterThan(endBefore);
|
|
expect(process.stdin.listenerCount('error')).toBeGreaterThan(errorBefore);
|
|
});
|
|
|
|
const backend = createMockBackend();
|
|
|
|
try {
|
|
await startMCPServer(backend);
|
|
} finally {
|
|
connectSpy.mockRestore();
|
|
exitStub.mockRestore();
|
|
// Remove only listeners added by startMCPServer so no side effects leak.
|
|
for (const listener of process.stdin.listeners('end')) {
|
|
if (!beforeListeners.stdinEnd.has(listener)) process.stdin.removeListener('end', listener);
|
|
}
|
|
for (const listener of process.stdin.listeners('close')) {
|
|
if (!beforeListeners.stdinClose.has(listener)) {
|
|
process.stdin.removeListener('close', listener);
|
|
}
|
|
}
|
|
for (const listener of process.stdin.listeners('error')) {
|
|
if (!beforeListeners.stdinError.has(listener)) {
|
|
process.stdin.removeListener('error', listener);
|
|
}
|
|
}
|
|
for (const listener of process.stdout.listeners('error')) {
|
|
if (!beforeListeners.stdoutError.has(listener)) {
|
|
process.stdout.removeListener('error', listener);
|
|
}
|
|
}
|
|
for (const listener of process.listeners('SIGINT')) {
|
|
if (!beforeListeners.sigint.has(listener)) process.removeListener('SIGINT', listener);
|
|
}
|
|
for (const listener of process.listeners('SIGTERM')) {
|
|
if (!beforeListeners.sigterm.has(listener)) process.removeListener('SIGTERM', listener);
|
|
}
|
|
for (const listener of process.listeners('exit')) {
|
|
if (!beforeListeners.exit.has(listener)) process.removeListener('exit', listener);
|
|
}
|
|
for (const listener of process.listeners('uncaughtException')) {
|
|
if (!beforeListeners.uncaughtException.has(listener)) {
|
|
process.removeListener('uncaughtException', listener);
|
|
}
|
|
}
|
|
for (const listener of process.listeners('unhandledRejection')) {
|
|
if (!beforeListeners.unhandledRejection.has(listener)) {
|
|
process.removeListener('unhandledRejection', listener);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
// ─── Graceful shutdown signal handling (#1132) ────────────────────────
|
|
|
|
describe('installSignalShutdown (#1132)', () => {
|
|
it('maps SIGINT→130 / SIGTERM→143 and never passes the signal name to shutdown', () => {
|
|
// Node invokes signal listeners with the signal NAME string as the first
|
|
// argument. The old code registered `shutdown` directly, so that string
|
|
// reached process.exit() and crashed with ERR_INVALID_ARG_TYPE. Reproduce
|
|
// that exact invocation and assert a numeric code is used instead.
|
|
const received: unknown[] = [];
|
|
let onSigint: ((...args: unknown[]) => void) | undefined;
|
|
let onSigterm: ((...args: unknown[]) => void) | undefined;
|
|
|
|
installSignalShutdown(
|
|
(code) => received.push(code),
|
|
(event, listener) => {
|
|
if (event === 'SIGINT') onSigint = listener;
|
|
if (event === 'SIGTERM') onSigterm = listener;
|
|
},
|
|
);
|
|
|
|
expect(onSigint).toBeTypeOf('function');
|
|
expect(onSigterm).toBeTypeOf('function');
|
|
|
|
// Invoke exactly as Node does — with the signal name string as the arg.
|
|
onSigint?.('SIGINT');
|
|
onSigterm?.('SIGTERM');
|
|
|
|
expect(received).toEqual([SHUTDOWN_EXIT_CODES.SIGINT, SHUTDOWN_EXIT_CODES.SIGTERM]);
|
|
expect(received).toEqual([130, 143]);
|
|
for (const code of received) {
|
|
expect(typeof code).toBe('number');
|
|
}
|
|
});
|
|
});
|
|
|
|
// Response filters are optional transport views. Backends and unfiltered bytes
|
|
// retain their established contract, including hints and safety metadata.
|
|
describe('MCP response filters', () => {
|
|
const payload = {
|
|
status: 'found',
|
|
symbol: { uid: 'Function:src/pay.ts:pay', name: 'pay' },
|
|
incoming: {
|
|
calls: [{ uid: 'Function:src/buy.ts:buy' }],
|
|
uses: [{ uid: 'Variable:src/ui.ts:handler' }],
|
|
},
|
|
outgoing: { calls: [{ uid: 'Function:src/db.ts:save' }] },
|
|
processes: [{ id: 'proc:checkout' }],
|
|
epistemic: 'lower-bound',
|
|
causes: { callableValueReferences: 1 },
|
|
warning: 'Dynamic dispatch unresolved',
|
|
staleness: { status: 'current', lastCommit: 'abc' },
|
|
};
|
|
it('returns compact JSON with all default evidence and hints', async () => {
|
|
const backend = createMockBackend({ callTool: vi.fn().mockResolvedValue(payload) });
|
|
const args = { uid: payload.symbol.uid };
|
|
const { text, isError } = await callToolThroughServer(backend, 'context', args);
|
|
expect(isError).toBe(false);
|
|
expect(text).toBe(JSON.stringify(payload) + getNextStepHint('context', args, false, payload));
|
|
expect(backend.callTool).toHaveBeenCalledWith('context', args);
|
|
});
|
|
it('preserves source whitespace, Unicode, nested values and incomplete-evidence diagnostics', async () => {
|
|
const result = {
|
|
...payload,
|
|
content: 'function café() {\n return "雪 😀 \\"quoted\\"";\n}\n',
|
|
nested: [null, false, 0, '', { lines: [' leading', 'trailing ', '\tindent'] }],
|
|
partial: true,
|
|
truncated: true,
|
|
};
|
|
const backend = createMockBackend({ callTool: vi.fn().mockResolvedValue(result) });
|
|
const args = { uid: payload.symbol.uid, include_content: true };
|
|
const { text, isError } = await callToolThroughServer(backend, 'context', args);
|
|
const hint = getNextStepHint('context', args, false, result);
|
|
expect(isError).toBe(false);
|
|
expect(text.endsWith(hint)).toBe(true);
|
|
expect(JSON.parse(text.slice(0, -hint.length))).toEqual(result);
|
|
});
|
|
it('keeps complete evidence when compact JSON and its hint fit the requested budget', async () => {
|
|
const backend = createMockBackend({ callTool: vi.fn().mockResolvedValue(payload) });
|
|
const args = { uid: payload.symbol.uid };
|
|
const hint = getNextStepHint('context', args, false, payload);
|
|
const complete = JSON.stringify(payload) + hint;
|
|
const maxTokens = Math.ceil(Buffer.byteLength(complete) / 4);
|
|
expect(Buffer.byteLength(JSON.stringify(payload, null, 2) + hint)).toBeGreaterThan(
|
|
maxTokens * 4,
|
|
);
|
|
const { text, isError } = await callToolThroughServer(backend, 'context', {
|
|
...args,
|
|
maxTokens,
|
|
});
|
|
expect(isError).toBe(false);
|
|
expect(text).toBe(complete);
|
|
expect(JSON.parse(text.slice(0, -hint.length))).toEqual(payload);
|
|
});
|
|
it('passes plain-text backend results through byte-for-byte before the hint', async () => {
|
|
const result = 'name | count\n 雪 😀 | 1\t\n';
|
|
const backend = createMockBackend({ callTool: vi.fn().mockResolvedValue(result) });
|
|
const args = { statement: 'RETURN 1' };
|
|
const { text, isError } = await callToolThroughServer(backend, 'cypher', args);
|
|
expect(isError).toBe(false);
|
|
expect(text).toBe(result + getNextStepHint('cypher', args, false, result));
|
|
});
|
|
it.each(['context', 'explore'])(
|
|
'applies opt-in views for %s without sending filter options to the backend',
|
|
async (name) => {
|
|
const backend = createMockBackend({ callTool: vi.fn().mockResolvedValue(payload) });
|
|
const { text, isError } = await callToolThroughServer(backend, name, {
|
|
uid: payload.symbol.uid,
|
|
response_sections: ['incoming'],
|
|
relationTypes: ['CALLS'],
|
|
});
|
|
expect(isError).toBe(false);
|
|
const result = JSON.parse(text.split('\n\n---')[0]);
|
|
expect(result.incoming).toEqual({ calls: payload.incoming.calls });
|
|
expect(result.symbol).toEqual(payload.symbol);
|
|
expect(result.epistemic).toBe('lower-bound');
|
|
expect(result.causes).toEqual(payload.causes);
|
|
expect(result.warning).toBe(payload.warning);
|
|
expect(result.staleness).toEqual(payload.staleness);
|
|
expect(result).not.toHaveProperty('outgoing');
|
|
expect(result).not.toHaveProperty('processes');
|
|
expect(result.response_filter.omitted_relations).toEqual({ incoming: ['uses'] });
|
|
expect(backend.callTool).toHaveBeenCalledWith(name, { uid: payload.symbol.uid });
|
|
},
|
|
);
|
|
it.each(['query', 'search'])('selects query result sections through %s', async (name) => {
|
|
const data = {
|
|
processes: [{ id: 'proc:checkout' }],
|
|
process_symbols: [{ id: payload.symbol.uid, process_id: 'proc:checkout' }],
|
|
definitions: [],
|
|
};
|
|
const backend = createMockBackend({ callTool: vi.fn().mockResolvedValue(data) });
|
|
const { text, isError } = await callToolThroughServer(backend, name, {
|
|
search_query: 'pay',
|
|
response_sections: ['process_symbols', 'definitions'],
|
|
});
|
|
expect(isError).toBe(false);
|
|
const result = JSON.parse(text.split('\n\n---')[0]);
|
|
expect(result.process_symbols).toEqual(data.process_symbols);
|
|
expect(result.definitions).toEqual([]);
|
|
expect(result).not.toHaveProperty('processes');
|
|
expect(backend.callTool).toHaveBeenCalledWith(name, { search_query: 'pay' });
|
|
});
|
|
it.each([
|
|
{ response_sections: ['risk'] },
|
|
{ response_sections: [] },
|
|
{ relationTypes: ['CALSL'] },
|
|
{ response_sections: ['processes'], relationTypes: ['CALLS'] },
|
|
{ response_sections: ['incoming'], repo: '@group' },
|
|
])('rejects invalid filters before backend execution: %j', async (args) => {
|
|
const backend = createMockBackend();
|
|
const { isError } = await callToolThroughServer(backend, 'context', { name: 'pay', ...args });
|
|
expect(isError).toBe(true);
|
|
expect(backend.callTool).not.toHaveBeenCalled();
|
|
});
|
|
it('applies the existing byte budget after filtering, without changing the cutoff contract', async () => {
|
|
const backend = createMockBackend({ callTool: vi.fn().mockResolvedValue(payload) });
|
|
const { text, isError } = await callToolThroughServer(backend, 'context', {
|
|
uid: payload.symbol.uid,
|
|
response_sections: ['incoming'],
|
|
maxTokens: 8,
|
|
});
|
|
expect(isError).toBe(false);
|
|
expect(Buffer.byteLength(text)).toBeLessThanOrEqual(32);
|
|
expect(text.endsWith('\n…')).toBe(true);
|
|
expect(backend.callTool).toHaveBeenCalledWith('context', { uid: payload.symbol.uid });
|
|
});
|
|
});
|