old-docker-actions/ai-code-review
2
0
Fork 0
Code Pull Requests 1 Actions Releases 2 Activity

Refactor LLM verification and update dependencies

Browse Source 
- Removed OpenAI and related dependencies from package.json and package-lock.json.
- Simplified LLM verification logic to focus on OpenCode server.
- Updated tests to reflect changes in LLM provider handling.
- Added CI and CD workflows for automated processes in Gitea.
This commit is contained in:
jiantw83
2026-06-25 10:17:08 +00:00
parent 525f6f9350
commit 65f27f544b
11 changed files with 162 additions and 837 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/llm.test.js
+44 -158
View File
@@ -1,18 +1,9 @@
import { describe, it, beforeEach, afterEach, mock } from 'node:test';
import assert from 'node:assert/strict';
// Mock axios before importing llm.js
import axios from 'axios';
const ENV_KEYS = [
'OPENAI_API_KEY', 'OPENAI_BASE_URL', 'OPENAI_MODEL',
'GEMINI_API_KEY', 'GEMINI_BASE_URL', 'GEMINI_MODEL',
'CLAUDE_API_KEY', 'CLAUDE_BASE_URL', 'CLAUDE_MODEL',
'OLLAMA_BASE_URL', 'OLLAMA_MODEL',
'AMAZONQ_API_KEY', 'AMAZONQ_BASE_URL', 'AMAZONQ_MODEL',
'OPENCODE_BASE_URL', 'OPENCODE_MODEL', 'OPENCODE_PROVIDER',
'OPENCODE_SERVER_USERNAME', 'OPENCODE_SERVER_PASSWORD',
'OPENCODE_SKIP_TLS_VERIFY',
];
let saved = {};
@@ -28,108 +19,19 @@ afterEach(() => {
mock.restoreAll();
});
function mockAxiosPost(responses) {
let call = 0;
function mockOpenCodeResponse(content) {
let calls = 0;
mock.method(axios, 'post', async () => {
const r = responses[call++] ?? responses[responses.length - 1];
if (r instanceof Error) throw r;
return r;
calls += 1;
if (calls === 1) return { data: { id: 'ses_test' } };
return { data: { parts: [{ type: 'text', text: content }] } };
});
}
function makeOkResponse(content = 'ok') {
return { data: { choices: [{ message: { content } }] } };
}
describe('chat - key rotation', async () => {
describe('chat - OpenCode', async () => {
const { chat } = await import('./llm.js');
it('succeeds on first key', async () => {
process.env.OPENAI_API_KEY = 'key1';
mockAxiosPost([makeOkResponse('hello')]);
const result = await chat('sys', 'user');
assert.equal(result, 'hello');
});
it('shuffles keys and tries each exactly once', async () => {
process.env.OPENAI_API_KEY = 'key1,key2,key3';
const usedKeys = [];
mock.method(axios, 'post', async (_url, _body, opts) => {
usedKeys.push(opts.headers['Authorization'].replace('Bearer ', ''));
throw new Error('fail');
});
const exitMock = mock.method(process, 'exit', () => { throw new Error('exit:1'); });
await assert.rejects(() => chat('sys', 'user'), /exit:1/);
assert.equal(exitMock.mock.calls[0].arguments[0], 1);
assert.equal(usedKeys.length, 3);
assert.deepEqual([...usedKeys].sort(), ['key1', 'key2', 'key3']);
});
it('calls process.exit(1) when all keys fail', async () => {
process.env.OPENAI_API_KEY = 'k1,k2';
mockAxiosPost([new Error('fail'), new Error('fail')]);
const exitMock = mock.method(process, 'exit', () => { throw new Error('exit:1'); });
await assert.rejects(() => chat('sys', 'user'), /exit:1/);
assert.equal(exitMock.mock.calls[0].arguments[0], 1);
});
it('does not set Authorization header for ollama', async () => {
process.env.OLLAMA_BASE_URL = 'http://localhost:11434/v1';
process.env.OLLAMA_MODEL = 'llama3';
let capturedHeaders;
mock.method(axios, 'post', async (_url, _body, opts) => {
capturedHeaders = opts.headers;
return makeOkResponse('ollama response');
});
await chat('sys', 'user');
assert.equal(capturedHeaders['Authorization'], undefined);
});
it('sets Authorization header for openai', async () => {
process.env.OPENAI_API_KEY = 'sk-test';
let capturedHeaders;
mock.method(axios, 'post', async (_url, _body, opts) => {
capturedHeaders = opts.headers;
return makeOkResponse();
});
await chat('sys', 'user');
assert.equal(capturedHeaders['Authorization'], 'Bearer sk-test');
});
it('does not set timeout', async () => {
process.env.OPENAI_API_KEY = 'sk-test';
let capturedOpts;
mock.method(axios, 'post', async (_url, _body, opts) => {
capturedOpts = opts;
return makeOkResponse();
});
await chat('sys', 'user');
assert.equal(capturedOpts.timeout, undefined);
});
it('does not pass httpsAgent to axios', async () => {
process.env.OPENAI_API_KEY = 'sk-test';
let capturedOpts;
mock.method(axios, 'post', async (_url, _body, opts) => {
capturedOpts = opts;
return makeOkResponse();
});
await chat('sys', 'user');
assert.equal(capturedOpts.httpsAgent, undefined);
});
it('sets anthropic-version header for claude', async () => {
process.env.CLAUDE_API_KEY = 'claude-key';
let capturedHeaders;
mock.method(axios, 'post', async (_url, _body, opts) => {
capturedHeaders = opts.headers;
return makeOkResponse();
});
await chat('sys', 'user');
assert.equal(capturedHeaders['anthropic-version'], '2023-06-01');
});
it('uses OpenCode server session API for opencode', async () => {
it('uses OpenCode server session API', async () => {
process.env.OPENCODE_BASE_URL = 'http://opencode.local:4096';
process.env.OPENCODE_PROVIDER = 'google';
process.env.OPENCODE_MODEL = 'gemini-2.5-flash';
@@ -139,7 +41,9 @@ describe('chat - key rotation', async () => {
if (url.endsWith('/session')) return { data: { id: 'ses_test' } };
return { data: { parts: [{ type: 'text', text: 'opencode response' }] } };
});
const result = await chat('sys', 'user');
assert.equal(result, 'opencode response');
assert.equal(calls[0].url, 'http://opencode.local:4096/session');
assert.deepEqual(calls[0].payload.model, { providerID: 'google', id: 'gemini-2.5-flash' });
@@ -150,20 +54,6 @@ describe('chat - key rotation', async () => {
assert.equal(calls[1].headers['Authorization'], undefined);
});
it('uses Basic Auth for protected OpenCode server', async () => {
process.env.OPENCODE_BASE_URL = 'http://opencode.local:4096';
process.env.OPENCODE_SERVER_USERNAME = 'opencode';
process.env.OPENCODE_SERVER_PASSWORD = 'secret';
const headers = [];
mock.method(axios, 'post', async (url, _payload, opts) => {
headers.push(opts.headers);
if (url.endsWith('/session')) return { data: { id: 'ses_test' } };
return { data: { parts: [{ type: 'text', text: 'ok' }] } };
});
await chat('sys', 'user');
assert.equal(headers[0]['Authorization'], `Basic ${Buffer.from('opencode:secret').toString('base64')}`);
});
it('passes an insecure https agent to OpenCode by default', async () => {
process.env.OPENCODE_BASE_URL = 'https://opencode.local:4096';
const agents = [];
@@ -172,41 +62,15 @@ describe('chat - key rotation', async () => {
if (url.endsWith('/session')) return { data: { id: 'ses_test' } };
return { data: { parts: [{ type: 'text', text: 'ok' }] } };
});
await chat('sys', 'user');
assert.equal(agents.length, 2);
assert.equal(agents[0].options.rejectUnauthorized, false);
assert.equal(agents[1].options.rejectUnauthorized, false);
});
it('does not pass an insecure https agent to OpenCode when TLS verification is enabled', async () => {
process.env.OPENCODE_BASE_URL = 'https://opencode.local:4096';
process.env.OPENCODE_SKIP_TLS_VERIFY = 'false';
const agents = [];
mock.method(axios, 'post', async (url, _payload, opts) => {
agents.push(opts.httpsAgent);
if (url.endsWith('/session')) return { data: { id: 'ses_test' } };
return { data: { parts: [{ type: 'text', text: 'ok' }] } };
});
await chat('sys', 'user');
assert.deepEqual(agents, [undefined, undefined]);
});
it('uses Responses API for openai GPT-5.5', async () => {
process.env.OPENAI_API_KEY = 'sk-test';
process.env.OPENAI_MODEL = 'GPT-5.5';
let capturedUrl, capturedPayload;
mock.method(axios, 'post', async (url, payload) => {
capturedUrl = url;
capturedPayload = payload;
return { data: { output_text: 'gpt response' } };
});
const result = await chat('sys', 'user');
assert.equal(result, 'gpt response');
assert.equal(capturedUrl, 'https://api.openai.com/v1/responses');
assert.deepEqual(capturedPayload, { model: 'GPT-5.5', instructions: 'sys', input: 'user', temperature: 0.2 });
});
it('extracts opencode text from message parts', async () => {
it('extracts text from OpenCode message parts', async () => {
process.env.OPENCODE_BASE_URL = 'http://opencode.local:4096';
let calls = 0;
mock.method(axios, 'post', async () => {
@@ -214,46 +78,68 @@ describe('chat - key rotation', async () => {
if (calls === 1) return { data: { id: 'ses_test' } };
return { data: { parts: [{ type: 'text', text: 'hello' }, { type: 'text', text: ' world' }] } };
});
const result = await chat('sys', 'user');
assert.equal(result, 'hello world');
});
it('calls process.exit(1) when OpenCode fails', async () => {
process.env.OPENCODE_BASE_URL = 'http://opencode.local:4096';
mock.method(axios, 'post', async () => { throw new Error('fail'); });
const exitMock = mock.method(process, 'exit', () => { throw new Error('exit:1'); });
await assert.rejects(() => chat('sys', 'user'), /exit:1/);
assert.equal(exitMock.mock.calls[0].arguments[0], 1);
});
});
describe('chatJSON', async () => {
const { chatJSON } = await import('./llm.js');
it('parses plain JSON response', async () => {
process.env.OPENAI_API_KEY = 'sk-test';
mockAxiosPost([makeOkResponse('[{"level":"critical"}]')]);
process.env.OPENCODE_BASE_URL = 'http://opencode.local:4096';
mockOpenCodeResponse('[{"level":"critical"}]');
const result = await chatJSON('sys', 'user');
assert.deepEqual(result, [{ level: 'critical' }]);
});
it('strips markdown code block before parsing', async () => {
process.env.OPENAI_API_KEY = 'sk-test';
mockAxiosPost([makeOkResponse('```json\n[{"level":"info"}]\n```')]);
process.env.OPENCODE_BASE_URL = 'http://opencode.local:4096';
mockOpenCodeResponse('```json\n[{"level":"info"}]\n```');
const result = await chatJSON('sys', 'user');
assert.deepEqual(result, [{ level: 'info' }]);
});
it('extracts JSON array from surrounding prose', async () => {
process.env.OPENAI_API_KEY = 'sk-test';
mockAxiosPost([makeOkResponse('**Reviewing findings**\n\n[{"level":"warning","suggestion":"x"}]\n\nDone.')]);
process.env.OPENCODE_BASE_URL = 'http://opencode.local:4096';
mockOpenCodeResponse('**Reviewing findings**\n\n[{"level":"warning","suggestion":"x"}]\n\nDone.');
const result = await chatJSON('sys', 'user');
assert.deepEqual(result, [{ level: 'warning', suggestion: 'x' }]);
});
it('extracts JSON object from surrounding prose', async () => {
process.env.OPENAI_API_KEY = 'sk-test';
mockAxiosPost([makeOkResponse('**Begin Combine**\n{"merged_text":"repo block\\n\\nsource block"}')]);
process.env.OPENCODE_BASE_URL = 'http://opencode.local:4096';
mockOpenCodeResponse('**Begin Combine**\n{"merged_text":"repo block\\n\\nsource block"}');
const result = await chatJSON('sys', 'user');
assert.deepEqual(result, { merged_text: 'repo block\n\nsource block' });
});
it('returns [] when JSON is invalid', async () => {
process.env.OPENAI_API_KEY = 'sk-test';
mockAxiosPost([makeOkResponse('not json')]);
process.env.OPENCODE_BASE_URL = 'http://opencode.local:4096';
mockOpenCodeResponse('not json');
const result = await chatJSON('sys', 'user');
assert.deepEqual(result, []);
});
});