Add Context Engine MCP integration

Introduce optional Context Engine MCP support for repository-aware reviews. Adds new env/inputs (CONTEXT_ENGINE_API_KEY / context_engine_api_key, CONTEXT_ENGINE_MCP_URL / context_engine_mcp_url, CONTEXT_ENGINE_COLLECTION / context_engine_collection, CONTEXT_ENGINE_TOOLS / context_engine_tools, CONTEXT_ENGINE_MAX_TOOLS / context_engine_max_tools), documents usage and defaults in README, and exposes the flags in action.yml. Implements a new context_engine_mcp module and wires MCP tool exposure into review prompts (per-batch tool scoping), with graceful fallback to diff-only mode on failures. Includes tests for CLI, context engine integration and prompts, and updates built artifacts (dist) and related source files.

Author: m1rl0k

README.md

@@ -80,9 +80,110 @@ Common optional settings:
 - `ALLOW_TITLE_UPDATE`: set to `true` to allow title rewriting when the PR title explicitly asks for it.
 - `GITHUB_API_URL`: GitHub Enterprise API URL.
 - `GITHUB_SERVER_URL`: GitHub Enterprise web URL.
+- `CONTEXT_ENGINE_API_KEY` or `CTXCE_API_KEY`: optional Context Engine API key. When set, review prompts can call Context Engine MCP tools for repository context.
+- `CONTEXT_ENGINE_MCP_URL` or `CTXCE_INDEXER_URL`: optional Context Engine MCP indexer URL. Defaults to `https://dev.context-engine.ai/indexer/mcp`.
+- `CONTEXT_ENGINE_COLLECTION`: optional collection name to scope MCP searches.
+- `CONTEXT_ENGINE_TOOLS`: optional comma-separated MCP tool allow-list. Defaults to `repo_search,batch_search,symbol_graph,batch_symbol_graph,graph_query,batch_graph_query,search_tests_for,search_config_for,search_commits_for`.
+- `CONTEXT_ENGINE_MAX_TOOLS`: maximum MCP tools exposed to reviewer LLMs. Defaults to `9`.
 
 The action input names mirror the environment variables where applicable, for example `custom_mode`, `llm_model`, `llm_provider`, `github_api_url`, and `github_server_url`.
 
+### Optional Context Engine MCP access
+
+By default, the reviewer works from PR diffs only. This is the free/default mode and does not make Context Engine network calls.
+
+Customers who want repository-aware review can opt in by providing a Context Engine API key. When enabled, the reviewer exposes a small allow-list of explicit Context Engine MCP tools to the LLM during review inference. If MCP setup or tool discovery fails, the reviewer logs a warning and falls back to the normal diff-only path for that run.
+
+The default SaaS MCP endpoint is:
+
+```text
+https://dev.context-engine.ai/indexer/mcp
+```
+
+The memory MCP endpoint is not used by this reviewer.
+
+#### GitHub Action usage
+
+You can enable Context Engine either with action inputs or environment variables. Supplying the API key is the opt-in switch; no separate boolean flag is required.
+
+Using environment variables:
+
+```yaml
+env:
+  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+  LLM_PROVIDER: ai-sdk
+  LLM_MODEL: gpt-5-mini
+  LLM_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+  CONTEXT_ENGINE_API_KEY: ${{ secrets.CONTEXT_ENGINE_API_KEY }}
+  CONTEXT_ENGINE_COLLECTION: your-indexed-collection
+```
+
+Using action inputs:
+
+```yaml
+with:
+  github_token: ${{ secrets.GITHUB_TOKEN }}
+  llm_provider: ai-sdk
+  llm_model: gpt-5-mini
+  context_engine_api_key: ${{ secrets.CONTEXT_ENGINE_API_KEY }}
+  context_engine_collection: your-indexed-collection
+```
+
+Optional action inputs:
+
+- `context_engine_mcp_url`: defaults to `https://dev.context-engine.ai/indexer/mcp`.
+- `context_engine_tools`: comma-separated MCP tool allow-list.
+- `context_engine_max_tools`: maximum number of MCP tools exposed to the reviewer LLM. Defaults to `9`.
+
+#### Default tool allow-list
+
+The default allow-list intentionally exposes direct code/navigation tools only:
+
+- `repo_search`
+- `batch_search`
+- `symbol_graph`
+- `batch_symbol_graph`
+- `graph_query`
+- `batch_graph_query`
+- `search_tests_for`
+- `search_config_for`
+- `search_commits_for`
+
+The unified `search` router is excluded by default because it can be noisy for an autonomous reviewer. Memory tools are also excluded by default and the reviewer does not connect to the memory MCP endpoint. `search_commits_for` is included so the reviewer can inspect relevant commit history or historically co-changing files when that materially improves review quality.
+
+You can override the allow-list if needed:
+
+```yaml
+env:
+  CONTEXT_ENGINE_TOOLS: repo_search,batch_search,symbol_graph,search_tests_for
+```
+
+#### Review batching behavior
+
+Context Engine tools are available only during PR review prompts, not during the PR summary prompt. The reviewer still uses the normal PR diff batching strategy:
+
+1. Split changed files into review batches using `REVIEW_MAX_REVIEW_CHARS`.
+2. Invoke the review prompt once per batch.
+3. Expose Context Engine tools independently inside each batch inference.
+
+This avoids prefetching repository context for the whole PR and keeps tool calls scoped to the batch being reviewed.
+
+#### Local dry-run debugging
+
+For local dry-run debugging, set the same variables in `.env` or pass them directly to the CLI. The dry-run path still uses the normal PR diff batching loop, so Context Engine tools are available independently to each review batch instead of prefetching repository context for the whole PR.
+
+```bash
+npm run review -- --pr 123 --dry-run \
+  --context-engine-api-key "$CONTEXT_ENGINE_API_KEY" \
+  --context-engine-collection your-indexed-collection
+```
+
+Optional dry-run flags:
+
+- `--context-engine-mcp-url` / `--ce-url`
+- `--context-engine-tools` / `--ce-tools`
+- `--context-engine-max-tools` / `--ce-max-tools`
+
 ## Providers
 
 The reviewer uses the AI SDK provider surface. Direct API providers use `LLM_API_KEY`, Z.AI can use `ZAI_API_KEY`, and AWS Bedrock can use AWS credentials instead.

action.yml

@@ -38,6 +38,26 @@ inputs:
     required: false
     description: 'Z.AI OpenAI-compatible base URL for glm-* models'
     default: 'https://api.z.ai/api/coding/paas/v4/'
+  context_engine_api_key:
+    required: false
+    description: 'Optional Context Engine API key. When set, reviewer LLMs can call Context Engine MCP tools for repository context.'
+    default: ''
+  context_engine_mcp_url:
+    required: false
+    description: 'Optional Context Engine MCP indexer URL.'
+    default: 'https://dev.context-engine.ai/indexer/mcp'
+  context_engine_collection:
+    required: false
+    description: 'Optional Context Engine collection name to scope reviewer MCP searches.'
+    default: ''
+  context_engine_tools:
+    required: false
+    description: 'Optional comma-separated Context Engine MCP tools exposed to the reviewer LLM.'
+    default: 'repo_search,batch_search,symbol_graph,batch_symbol_graph,graph_query,batch_graph_query,search_tests_for,search_config_for,search_commits_for'
+  context_engine_max_tools:
+    required: false
+    description: 'Maximum number of Context Engine MCP tools exposed to the reviewer LLM.'
+    default: '9'
 
   review_scopes:
     required: false

dist/cli.js

@@ -0,0 +1,34 @@
+import { applyContextEngineCliOptions, parseArgs } from '../cli';
+
+describe('dry-run CLI Context Engine options', () => {
+  beforeEach(() => {
+    delete process.env.CONTEXT_ENGINE_API_KEY;
+    delete process.env.CONTEXT_ENGINE_MCP_URL;
+    delete process.env.CONTEXT_ENGINE_COLLECTION;
+    delete process.env.CONTEXT_ENGINE_TOOLS;
+    delete process.env.CONTEXT_ENGINE_MAX_TOOLS;
+  });
+
+  test('parses and applies Context Engine dry-run flags', () => {
+    const args = parseArgs([
+      '--pr', '42',
+      '--dry-run',
+      '--context-engine-api-key', 'ce-key',
+      '--context-engine-mcp-url', 'https://dev.context-engine.ai/indexer/mcp',
+      '--context-engine-collection', 'repo-col',
+      '--context-engine-tools', 'repo_search,batch_search',
+      '--context-engine-max-tools', '2',
+    ]);
+
+    expect(args.pr).toBe(42);
+    expect(args.dryRun).toBe(true);
+
+    applyContextEngineCliOptions(args);
+
+    expect(process.env.CONTEXT_ENGINE_API_KEY).toBe('ce-key');
+    expect(process.env.CONTEXT_ENGINE_MCP_URL).toBe('https://dev.context-engine.ai/indexer/mcp');
+    expect(process.env.CONTEXT_ENGINE_COLLECTION).toBe('repo-col');
+    expect(process.env.CONTEXT_ENGINE_TOOLS).toBe('repo_search,batch_search');
+    expect(process.env.CONTEXT_ENGINE_MAX_TOOLS).toBe('2');
+  });
+});

dist/main.js

@@ -127,6 +127,25 @@ describe('Config', () => {
     expect(config.githubServerUrl).toBe('https://github.example.com');
   });
 
+  test('loads optional Context Engine MCP configuration from environment', () => {
+    process.env.GITHUB_TOKEN = 'test-token';
+    process.env.LLM_API_KEY = 'test-api-key';
+    process.env.LLM_MODEL = 'test-model';
+    process.env.CONTEXT_ENGINE_API_KEY = 'ce-key';
+    process.env.CONTEXT_ENGINE_MCP_URL = 'https://dev.context-engine.ai/indexer/mcp';
+    process.env.CONTEXT_ENGINE_COLLECTION = 'repo-collection';
+    process.env.CONTEXT_ENGINE_TOOLS = 'repo_search,batch_search';
+    process.env.CONTEXT_ENGINE_MAX_TOOLS = '2';
+
+    const config = new Config();
+
+    expect(config.contextEngineApiKey).toBe('ce-key');
+    expect(config.contextEngineMcpUrl).toBe('https://dev.context-engine.ai/indexer/mcp');
+    expect(config.contextEngineCollection).toBe('repo-collection');
+    expect(config.contextEngineTools).toEqual(['repo_search', 'batch_search']);
+    expect(config.contextEngineMaxTools).toBe(2);
+  });
+
   //   test('skips loading inputs when DEBUG is set', () => {
   //     process.env.GITHUB_TOKEN = 'test-token';
   //     process.env.LLM_API_KEY = 'test-api-key';

src/__tests__/cli.test.ts

@@ -0,0 +1,189 @@
+import config from '../config';
+import { ContextEngineMcpClient, appendContextEngineToolInstructions, createContextEngineTools } from '../context_engine_mcp';
+
+jest.mock('@actions/core', () => ({
+  info: jest.fn(),
+  warning: jest.fn(),
+  getInput: jest.fn(() => ''),
+  getMultilineInput: jest.fn(() => []),
+}));
+
+describe('Context Engine MCP integration', () => {
+  const originalFetch = global.fetch;
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    (config as any).contextEngineApiKey = 'ce-key';
+    (config as any).contextEngineMcpUrl = 'https://dev.context-engine.ai/indexer/mcp';
+    (config as any).contextEngineCollection = 'repo-collection';
+    (config as any).contextEngineTools = ['repo_search', 'batch_search'];
+    (config as any).contextEngineMaxTools = 9;
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+  });
+
+  function jsonResponse(body: unknown, headers?: Record<string, string>): Response {
+    return new Response(JSON.stringify(body), { status: 200, headers });
+  }
+
+  test('lists remote MCP tools with bearer auth and session reuse', async () => {
+    const fetchMock = jest.fn()
+      .mockResolvedValueOnce(jsonResponse({ result: {} }, { 'mcp-session-id': 'session-1' }))
+      .mockResolvedValueOnce(new Response('', { status: 202 }))
+      .mockResolvedValueOnce(jsonResponse({ result: { tools: [{ name: 'search', description: 'Search code' }] } }));
+    global.fetch = fetchMock as any;
+
+    const client = new ContextEngineMcpClient({
+      url: 'https://dev.context-engine.ai/indexer/mcp',
+      apiKey: 'ce-key',
+      collection: 'repo-collection',
+    });
+
+    const tools = await client.listTools();
+
+    expect(tools).toEqual([{ name: 'search', description: 'Search code' }]);
+    expect(fetchMock).toHaveBeenCalledTimes(3);
+    expect(fetchMock.mock.calls[0][1].headers.authorization).toBe('Bearer ce-key');
+    expect(fetchMock.mock.calls[0][1].headers['x-collection']).toBe('repo-collection');
+    expect(fetchMock.mock.calls[2][1].headers['mcp-session-id']).toBe('session-1');
+  });
+
+  test('tool calls add reviewer-safe compact defaults and collection', async () => {
+    const fetchMock = jest.fn()
+      .mockResolvedValueOnce(jsonResponse({ result: {} }, { 'mcp-session-id': 'session-1' }))
+      .mockResolvedValueOnce(new Response('', { status: 202 }))
+      .mockResolvedValueOnce(jsonResponse({ result: { content: [{ type: 'text', text: 'ok' }] } }));
+    global.fetch = fetchMock as any;
+
+    const client = new ContextEngineMcpClient({
+      url: 'https://dev.context-engine.ai/indexer/mcp',
+      apiKey: 'ce-key',
+      collection: 'repo-collection',
+    });
+
+    await client.callTool('repo_search', { query: 'authentication' });
+
+    const callBody = JSON.parse(fetchMock.mock.calls[2][1].body);
+    expect(callBody.method).toBe('tools/call');
+    expect(callBody.params.name).toBe('repo_search');
+    expect(callBody.params.arguments).toEqual(expect.objectContaining({
+      query: 'authentication',
+      collection: 'repo-collection',
+      limit: 5,
+      compact: true,
+      include_snippet: true,
+      output_format: 'toon',
+    }));
+  });
+
+  test('creates AI SDK tools from the configured remote MCP allow-list', async () => {
+    const fetchMock = jest.fn()
+      .mockResolvedValueOnce(jsonResponse({ result: {} }, { 'mcp-session-id': 'session-1' }))
+      .mockResolvedValueOnce(new Response('', { status: 202 }))
+      .mockResolvedValueOnce(jsonResponse({ result: { tools: [
+        { name: 'search', description: 'Noisy router', inputSchema: { type: 'object' } },
+        { name: 'repo_search', description: 'Search code', inputSchema: { type: 'object' } },
+        { name: 'batch_search', description: 'Batch search code', inputSchema: { type: 'object' } },
+        { name: 'memory_store', description: 'Do not expose by default', inputSchema: { type: 'object' } },
+      ] } }));
+    global.fetch = fetchMock as any;
+
+    const tools = await createContextEngineTools();
+
+    expect(Object.keys(tools || {})).toEqual(['repo_search', 'batch_search']);
+  });
+
+  test('default allow-list excludes unified search router and memory tools', async () => {
+    (config as any).contextEngineTools = [];
+    const fetchMock = jest.fn()
+      .mockResolvedValueOnce(jsonResponse({ result: {} }, { 'mcp-session-id': 'session-1' }))
+      .mockResolvedValueOnce(new Response('', { status: 202 }))
+      .mockResolvedValueOnce(jsonResponse({ result: { tools: [
+        { name: 'search', description: 'Noisy router', inputSchema: { type: 'object' } },
+        { name: 'repo_search', description: 'Repo search', inputSchema: { type: 'object' } },
+        { name: 'batch_search', description: 'Batch repo search', inputSchema: { type: 'object' } },
+        { name: 'symbol_graph', description: 'Symbol graph', inputSchema: { type: 'object' } },
+        { name: 'batch_symbol_graph', description: 'Batch symbol graph', inputSchema: { type: 'object' } },
+        { name: 'graph_query', description: 'Graph query', inputSchema: { type: 'object' } },
+        { name: 'batch_graph_query', description: 'Batch graph query', inputSchema: { type: 'object' } },
+        { name: 'search_tests_for', description: 'Tests', inputSchema: { type: 'object' } },
+        { name: 'search_config_for', description: 'Config', inputSchema: { type: 'object' } },
+        { name: 'search_commits_for', description: 'Git history', inputSchema: { type: 'object' } },
+        { name: 'memory_find', description: 'Memory', inputSchema: { type: 'object' } },
+      ] } }));
+    global.fetch = fetchMock as any;
+
+    const tools = await createContextEngineTools();
+
+    expect(Object.keys(tools || {})).toEqual([
+      'repo_search',
+      'batch_search',
+      'symbol_graph',
+      'batch_symbol_graph',
+      'graph_query',
+      'batch_graph_query',
+      'search_tests_for',
+      'search_config_for',
+      'search_commits_for',
+    ]);
+  });
+
+  test('does not add snippet defaults to graph tools', async () => {
+    const fetchMock = jest.fn()
+      .mockResolvedValueOnce(jsonResponse({ result: {} }, { 'mcp-session-id': 'session-1' }))
+      .mockResolvedValueOnce(new Response('', { status: 202 }))
+      .mockResolvedValueOnce(jsonResponse({ result: { content: [{ type: 'text', text: 'ok' }] } }));
+    global.fetch = fetchMock as any;
+
+    const client = new ContextEngineMcpClient({
+      url: 'https://dev.context-engine.ai/indexer/mcp',
+      apiKey: 'ce-key',
+      collection: 'repo-collection',
+    });
+
+    await client.callTool('symbol_graph', { symbol: 'authenticate', query_type: 'callers' });
+
+    const callBody = JSON.parse(fetchMock.mock.calls[2][1].body);
+    expect(callBody.params.arguments).toEqual(expect.objectContaining({
+      symbol: 'authenticate',
+      query_type: 'callers',
+      collection: 'repo-collection',
+      limit: 5,
+      output_format: 'toon',
+    }));
+    expect(callBody.params.arguments).not.toHaveProperty('compact');
+    expect(callBody.params.arguments).not.toHaveProperty('include_snippet');
+  });
+
+  test('does not add output-format defaults to git history tools', async () => {
+    const fetchMock = jest.fn()
+      .mockResolvedValueOnce(jsonResponse({ result: {} }, { 'mcp-session-id': 'session-1' }))
+      .mockResolvedValueOnce(new Response('', { status: 202 }))
+      .mockResolvedValueOnce(jsonResponse({ result: { content: [{ type: 'text', text: 'ok' }] } }));
+    global.fetch = fetchMock as any;
+
+    const client = new ContextEngineMcpClient({
+      url: 'https://dev.context-engine.ai/indexer/mcp',
+      apiKey: 'ce-key',
+      collection: 'repo-collection',
+    });
+
+    await client.callTool('search_commits_for', { query: 'authentication bug' });
+
+    const callBody = JSON.parse(fetchMock.mock.calls[2][1].body);
+    expect(callBody.params.arguments).toEqual(expect.objectContaining({
+      query: 'authentication bug',
+      collection: 'repo-collection',
+      limit: 5,
+    }));
+    expect(callBody.params.arguments).not.toHaveProperty('output_format');
+    expect(callBody.params.arguments).not.toHaveProperty('include_snippet');
+  });
+
+  test('does not alter system prompt when Context Engine is not configured', () => {
+    (config as any).contextEngineApiKey = undefined;
+    expect(appendContextEngineToolInstructions('sys')).toBe('sys');
+  });
+});