@jawkx1999/opencr 0.1.0-alpha.2 → 0.1.0-alpha.4

package/dist/server/core/agents/opencode.js

@@ -0,0 +1,685 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { once } from 'node:events';
+import { resolve } from 'node:path';
+const OPENCODE_BACKEND_ID = 'opencode';
+const CODEX_BACKEND_ID = 'codex';
+const SERVER_LISTENING_PATTERN = /opencode server listening on\s+(https?:\/\/\S+)/i;
+const MAX_DIFF_CONTEXT_CHARS = 14000;
+const EVENT_STREAM_RECONNECT_DELAY_MS = 350;
+const toErrorMessage = (error) => {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+};
+const isObject = (value) => {
+    return typeof value === 'object' && value !== null;
+};
+const toIdleStatus = () => ({
+    type: 'idle',
+});
+const parseSessionStatus = (value) => {
+    if (!isObject(value) || typeof value.type !== 'string') {
+        return toIdleStatus();
+    }
+    if (value.type === 'busy') {
+        return {
+            type: 'busy',
+        };
+    }
+    if (value.type === 'retry' &&
+        typeof value.attempt === 'number' &&
+        typeof value.message === 'string' &&
+        typeof value.next === 'number') {
+        return {
+            type: 'retry',
+            attempt: value.attempt,
+            message: value.message,
+            next: value.next,
+        };
+    }
+    return toIdleStatus();
+};
+const parseModelReference = (modelId) => {
+    const trimmed = modelId.trim();
+    const slashIndex = trimmed.indexOf('/');
+    if (slashIndex <= 0 || slashIndex >= trimmed.length - 1) {
+        throw new Error(`Invalid model id: ${modelId}. Expected provider/model.`);
+    }
+    return {
+        providerID: trimmed.slice(0, slashIndex),
+        modelID: trimmed.slice(slashIndex + 1),
+    };
+};
+const normalizeTarget = (target, defaultModelId) => {
+    const backendId = target?.backendId ?? OPENCODE_BACKEND_ID;
+    return {
+        backendId,
+        modelId: target?.modelId ?? defaultModelId,
+        variant: target?.variant ?? null,
+    };
+};
+const assertOpencodeBackend = (backendId) => {
+    if (backendId === OPENCODE_BACKEND_ID) {
+        return;
+    }
+    if (backendId === CODEX_BACKEND_ID) {
+        throw new Error('Codex backend is not implemented yet.');
+    }
+    throw new Error(`Unsupported agent backend: ${backendId}`);
+};
+const formatRangeLabel = (range) => {
+    const startSide = range.side === 'deletions' ? 'L' : 'R';
+    const endSide = range.endSide === 'deletions' ? 'L' : range.endSide === 'additions' ? 'R' : startSide;
+    const start = `${startSide}${range.start}`;
+    const end = `${endSide}${range.end}`;
+    return start === end ? start : `${start} to ${end}`;
+};
+const truncateDiff = (patch) => {
+    if (patch.length <= MAX_DIFF_CONTEXT_CHARS) {
+        return patch;
+    }
+    return `${patch.slice(0, MAX_DIFF_CONTEXT_CHARS)}\n\n[diff truncated by opencr]`;
+};
+const buildSessionTitle = (input) => {
+    const fileLabel = input.selection.fileLabel.split('/').at(-1) ?? input.selection.fileLabel;
+    const trimmedPrompt = input.prompt.trim().replace(/\s+/g, ' ');
+    if (trimmedPrompt.length === 0) {
+        return `Review ${fileLabel}`;
+    }
+    const suffix = trimmedPrompt.length > 46 ? `${trimmedPrompt.slice(0, 46)}...` : trimmedPrompt;
+    return `Review ${fileLabel}: ${suffix}`;
+};
+const buildSystemContext = (input) => {
+    return [
+        'You are assisting a code review session launched from opencr.',
+        `Selected file: ${input.selection.fileLabel}`,
+        `Selected range: ${formatRangeLabel(input.selection.range)}`,
+        'Focus your answer on the selected range, but use the full diff context when needed.',
+        '',
+        'Full diff context:',
+        truncateDiff(input.diffPatch),
+    ].join('\n');
+};
+const toUnavailableCatalog = (reason) => {
+    return {
+        backends: [
+            {
+                id: OPENCODE_BACKEND_ID,
+                label: 'OpenCode',
+                available: false,
+                reason,
+                defaultModelId: null,
+                models: [],
+            },
+            {
+                id: CODEX_BACKEND_ID,
+                label: 'Codex',
+                available: false,
+                reason: 'Codex backend is not implemented yet.',
+                defaultModelId: null,
+                models: [],
+            },
+        ],
+        defaultTarget: null,
+    };
+};
+class OpencodeUnavailableService {
+    reason;
+    constructor(reason) {
+        this.reason = reason;
+    }
+    getStatus() {
+        return {
+            available: false,
+            reason: this.reason,
+        };
+    }
+    async getCatalog() {
+        return toUnavailableCatalog(this.reason);
+    }
+    async createSession() {
+        throw new Error(this.reason);
+    }
+    async getSessionStatus() {
+        throw new Error(this.reason);
+    }
+    async listMessages() {
+        throw new Error(this.reason);
+    }
+    async sendMessage() {
+        throw new Error(this.reason);
+    }
+    subscribeEvents() {
+        return () => {
+            return;
+        };
+    }
+    async stop() {
+        return;
+    }
+}
+class OpencodeService {
+    repositoryPath;
+    process = null;
+    baseUrl = null;
+    ensureReadyTask = null;
+    eventStreamTask = null;
+    eventStreamAbortController = null;
+    eventListeners = new Set();
+    sessionStatusById = new Map();
+    modelsCache = null;
+    isStopping = false;
+    lastFailureReason = null;
+    constructor(repositoryPath) {
+        this.repositoryPath = repositoryPath;
+    }
+    getStatus() {
+        if (this.lastFailureReason != null) {
+            return {
+                available: false,
+                reason: this.lastFailureReason,
+            };
+        }
+        return {
+            available: true,
+            reason: null,
+        };
+    }
+    async getCatalog() {
+        let models = [];
+        let modelError = null;
+        try {
+            models = this.listOpencodeModels();
+        }
+        catch (error) {
+            modelError = toErrorMessage(error);
+        }
+        const available = this.lastFailureReason == null && modelError == null;
+        const unavailableReason = this.lastFailureReason ?? modelError;
+        const defaultModelId = models.at(0) ?? null;
+        return {
+            backends: [
+                {
+                    id: OPENCODE_BACKEND_ID,
+                    label: 'OpenCode',
+                    available,
+                    reason: unavailableReason,
+                    defaultModelId,
+                    models: models.map((modelId) => ({
+                        id: modelId,
+                        label: modelId,
+                    })),
+                },
+                {
+                    id: CODEX_BACKEND_ID,
+                    label: 'Codex',
+                    available: false,
+                    reason: 'Codex backend is not implemented yet.',
+                    defaultModelId: null,
+                    models: [],
+                },
+            ],
+            defaultTarget: available
+                ? {
+                    backendId: OPENCODE_BACKEND_ID,
+                    modelId: defaultModelId,
+                    variant: null,
+                }
+                : null,
+        };
+    }
+    subscribeEvents(listener) {
+        this.eventListeners.add(listener);
+        void this.ensureEventStream();
+        listener({
+            kind: 'connected',
+        });
+        return () => {
+            this.eventListeners.delete(listener);
+            if (this.eventListeners.size === 0) {
+                this.eventStreamAbortController?.abort();
+                this.eventStreamAbortController = null;
+                this.eventStreamTask = null;
+            }
+        };
+    }
+    async getSessionStatus(input) {
+        assertOpencodeBackend(input.backendId);
+        await this.ensureReady();
+        const statusBySessionId = await this.requestJson('/session/status', {
+            method: 'GET',
+        });
+        for (const [knownSessionId, status] of Object.entries(statusBySessionId)) {
+            this.sessionStatusById.set(knownSessionId, parseSessionStatus(status));
+        }
+        for (const knownSessionId of this.sessionStatusById.keys()) {
+            if (!(knownSessionId in statusBySessionId)) {
+                this.sessionStatusById.set(knownSessionId, toIdleStatus());
+            }
+        }
+        return this.sessionStatusById.get(input.sessionId) ?? toIdleStatus();
+    }
+    async createSession(input) {
+        const catalog = await this.getCatalog();
+        const opencodeCatalog = catalog.backends.find((backend) => backend.id === OPENCODE_BACKEND_ID) ?? null;
+        const target = normalizeTarget(input.target, opencodeCatalog?.defaultModelId ?? null);
+        assertOpencodeBackend(target.backendId);
+        const created = await this.requestJson('/session', {
+            method: 'POST',
+            body: {
+                title: buildSessionTitle(input),
+            },
+        });
+        const promptBody = {
+            system: buildSystemContext(input),
+            parts: [
+                {
+                    type: 'text',
+                    text: input.prompt,
+                },
+            ],
+        };
+        if (target.modelId != null) {
+            promptBody.model = parseModelReference(target.modelId);
+        }
+        if (target.variant != null) {
+            promptBody.variant = target.variant;
+        }
+        await this.requestJson(`/session/${created.id}/prompt_async`, {
+            method: 'POST',
+            body: promptBody,
+        });
+        const messages = await this.listMessages({
+            backendId: OPENCODE_BACKEND_ID,
+            sessionId: created.id,
+        });
+        this.sessionStatusById.set(created.id, {
+            type: 'busy',
+        });
+        return {
+            session: {
+                backendId: OPENCODE_BACKEND_ID,
+                backendSessionId: created.id,
+                modelId: target.modelId,
+                variant: target.variant,
+                title: created.title,
+                createdAt: created.time.created,
+                updatedAt: created.time.updated,
+            },
+            acceptedAt: Date.now(),
+            messages: messages.messages,
+        };
+    }
+    async listMessages(input) {
+        assertOpencodeBackend(input.backendId);
+        const result = await this.requestJson(`/session/${input.sessionId}/message`, {
+            method: 'GET',
+        });
+        const messages = result
+            .filter((entry) => entry.info.role === 'user' || entry.info.role === 'assistant')
+            .map((entry) => {
+            const textParts = entry.parts
+                .filter((part) => part.type === 'text' && typeof part.text === 'string' && !part.ignored)
+                .map((part) => part.text ?? '')
+                .filter((text) => text.trim().length > 0);
+            const joinedText = textParts.join('\n\n').trim();
+            const text = joinedText.length > 0
+                ? joinedText
+                : entry.info.role === 'assistant' && entry.info.error?.message
+                    ? `Error: ${entry.info.error.message}`
+                    : '[no text output]';
+            return {
+                id: entry.info.id,
+                role: entry.info.role,
+                text,
+                createdAt: entry.info.time.created,
+                completedAt: entry.info.role === 'assistant' ? (entry.info.time.completed ?? null) : null,
+            };
+        });
+        return {
+            messages,
+        };
+    }
+    async sendMessage(input) {
+        assertOpencodeBackend(input.backendId);
+        await this.requestJson(`/session/${input.sessionId}/prompt_async`, {
+            method: 'POST',
+            body: {
+                parts: [
+                    {
+                        type: 'text',
+                        text: input.request.prompt,
+                    },
+                ],
+            },
+        });
+        this.sessionStatusById.set(input.sessionId, {
+            type: 'busy',
+        });
+        const messages = await this.listMessages({
+            backendId: OPENCODE_BACKEND_ID,
+            sessionId: input.sessionId,
+        });
+        return {
+            acceptedAt: Date.now(),
+            messages: messages.messages,
+        };
+    }
+    async stop() {
+        this.isStopping = true;
+        this.ensureReadyTask = null;
+        this.baseUrl = null;
+        this.eventStreamTask = null;
+        this.eventStreamAbortController?.abort();
+        this.eventStreamAbortController = null;
+        this.eventListeners.clear();
+        const current = this.process;
+        this.process = null;
+        if (current == null || current.killed) {
+            return;
+        }
+        current.kill('SIGTERM');
+        try {
+            await Promise.race([
+                once(current, 'exit'),
+                new Promise((_, reject) => {
+                    setTimeout(() => reject(new Error('Timed out while stopping opencode.')), 2500);
+                }),
+            ]);
+        }
+        catch {
+            current.kill('SIGKILL');
+        }
+    }
+    listOpencodeModels() {
+        if (this.modelsCache != null) {
+            return this.modelsCache;
+        }
+        const result = spawnSync('opencode', ['models'], {
+            encoding: 'utf8',
+        });
+        if (result.error) {
+            throw new Error(`Failed to list opencode models: ${toErrorMessage(result.error)}`);
+        }
+        if (result.status !== 0) {
+            const stderr = result.stderr?.trim() ?? '';
+            const stdout = result.stdout?.trim() ?? '';
+            throw new Error(stderr || stdout || `opencode models exited with code ${result.status}`);
+        }
+        this.modelsCache = result.stdout
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+        return this.modelsCache;
+    }
+    emitEvent(event) {
+        for (const listener of this.eventListeners) {
+            listener(event);
+        }
+    }
+    ensureEventStream() {
+        if (this.eventStreamTask != null) {
+            return this.eventStreamTask;
+        }
+        this.eventStreamTask = this.runEventStream().finally(() => {
+            this.eventStreamTask = null;
+        });
+        return this.eventStreamTask;
+    }
+    async runEventStream() {
+        while (!this.isStopping && this.eventListeners.size > 0) {
+            try {
+                await this.ensureReady();
+                if (this.baseUrl == null) {
+                    throw new Error('opencode server URL is not available.');
+                }
+                const controller = new AbortController();
+                this.eventStreamAbortController = controller;
+                const requestUrl = new URL('/global/event', this.baseUrl);
+                const response = await fetch(requestUrl, {
+                    method: 'GET',
+                    signal: controller.signal,
+                });
+                if (!response.ok) {
+                    const detail = (await response.text()).trim();
+                    throw new Error(`opencode event stream failed (${response.status})${detail.length > 0 ? `: ${detail}` : ''}`);
+                }
+                if (response.body == null) {
+                    throw new Error('opencode event stream body is empty.');
+                }
+                this.emitEvent({
+                    kind: 'connected',
+                });
+                this.lastFailureReason = null;
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = '';
+                while (true) {
+                    const next = await reader.read();
+                    if (next.done) {
+                        break;
+                    }
+                    buffer += decoder.decode(next.value, { stream: true });
+                    while (true) {
+                        const eventBoundaryMatch = buffer.match(/\r?\n\r?\n/);
+                        if (eventBoundaryMatch == null || eventBoundaryMatch.index == null) {
+                            break;
+                        }
+                        const chunk = buffer.slice(0, eventBoundaryMatch.index);
+                        buffer = buffer.slice(eventBoundaryMatch.index + eventBoundaryMatch[0].length);
+                        this.handleEventChunk(chunk);
+                    }
+                }
+            }
+            catch (error) {
+                if (this.isStopping) {
+                    return;
+                }
+                if (!this.isAbortError(error)) {
+                    // no-op; stream loop will reconnect automatically
+                }
+            }
+            finally {
+                this.eventStreamAbortController = null;
+            }
+            await new Promise((resolveWait) => {
+                setTimeout(resolveWait, EVENT_STREAM_RECONNECT_DELAY_MS);
+            });
+        }
+    }
+    handleEventChunk(chunk) {
+        const lines = chunk.replace(/\r/g, '').split('\n');
+        const data = lines
+            .filter((line) => line.startsWith('data:'))
+            .map((line) => line.slice(5).trimStart())
+            .join('\n')
+            .trim();
+        if (data.length === 0) {
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(data);
+        }
+        catch {
+            return;
+        }
+        this.handleGlobalEvent(parsed);
+    }
+    handleGlobalEvent(event) {
+        const payloadType = event.payload?.type;
+        if (typeof payloadType !== 'string') {
+            return;
+        }
+        if (event.directory && resolve(event.directory) !== this.repositoryPath) {
+            return;
+        }
+        if (payloadType === 'session.status') {
+            if (!isObject(event.payload?.properties)) {
+                return;
+            }
+            const sessionId = typeof event.payload.properties.sessionID === 'string'
+                ? event.payload.properties.sessionID
+                : null;
+            if (sessionId == null) {
+                return;
+            }
+            const status = parseSessionStatus(event.payload.properties.status);
+            this.sessionStatusById.set(sessionId, status);
+            this.emitEvent({
+                kind: 'session-status',
+                backendId: OPENCODE_BACKEND_ID,
+                sessionId,
+                status,
+            });
+            return;
+        }
+        if (payloadType !== 'message.updated') {
+            return;
+        }
+        if (!isObject(event.payload?.properties) || !isObject(event.payload.properties.info)) {
+            return;
+        }
+        const sessionId = typeof event.payload.properties.info.sessionID === 'string'
+            ? event.payload.properties.info.sessionID
+            : null;
+        if (sessionId == null) {
+            return;
+        }
+        this.emitEvent({
+            kind: 'message-updated',
+            backendId: OPENCODE_BACKEND_ID,
+            sessionId,
+        });
+    }
+    isAbortError(error) {
+        return isObject(error) && error.name === 'AbortError';
+    }
+    async requestJson(pathname, options) {
+        await this.ensureReady();
+        if (this.baseUrl == null) {
+            throw new Error('opencode server URL is not available.');
+        }
+        const requestUrl = new URL(pathname, this.baseUrl);
+        requestUrl.searchParams.set('directory', this.repositoryPath);
+        const hasBody = options.body !== undefined;
+        const requestInit = {
+            method: options.method,
+        };
+        if (hasBody) {
+            requestInit.headers = {
+                'Content-Type': 'application/json',
+            };
+            requestInit.body = JSON.stringify(options.body);
+        }
+        const response = await fetch(requestUrl, requestInit);
+        if (!response.ok) {
+            const detail = (await response.text()).trim();
+            throw new Error(`opencode request failed (${response.status})${detail.length > 0 ? `: ${detail}` : ''}`);
+        }
+        const text = await response.text();
+        if (text.trim().length === 0) {
+            return undefined;
+        }
+        return JSON.parse(text);
+    }
+    async ensureReady() {
+        if (this.baseUrl != null) {
+            return;
+        }
+        if (this.ensureReadyTask) {
+            await this.ensureReadyTask;
+            return;
+        }
+        this.isStopping = false;
+        this.ensureReadyTask = this.startServer().finally(() => {
+            this.ensureReadyTask = null;
+        });
+        await this.ensureReadyTask;
+    }
+    async startServer() {
+        const processHandle = spawn('opencode', ['serve', '--hostname', '127.0.0.1', '--port', '0'], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            cwd: this.repositoryPath,
+        });
+        this.process = processHandle;
+        let combinedOutput = '';
+        let resolved = false;
+        await new Promise((resolveStart, rejectStart) => {
+            const settleReady = (baseUrl) => {
+                if (resolved) {
+                    return;
+                }
+                resolved = true;
+                this.baseUrl = baseUrl;
+                this.lastFailureReason = null;
+                resolveStart();
+            };
+            const failStart = (reason) => {
+                if (resolved) {
+                    return;
+                }
+                resolved = true;
+                this.baseUrl = null;
+                this.lastFailureReason = reason;
+                rejectStart(new Error(reason));
+            };
+            const parseChunk = (chunk) => {
+                combinedOutput += chunk;
+                const match = chunk.match(SERVER_LISTENING_PATTERN) ?? combinedOutput.match(SERVER_LISTENING_PATTERN);
+                if (match?.[1]) {
+                    settleReady(match[1]);
+                }
+            };
+            processHandle.stdout?.setEncoding('utf8');
+            processHandle.stderr?.setEncoding('utf8');
+            processHandle.stdout?.on('data', parseChunk);
+            processHandle.stderr?.on('data', parseChunk);
+            processHandle.on('error', (error) => {
+                failStart(`Failed to start opencode: ${toErrorMessage(error)}`);
+            });
+            processHandle.on('exit', (code, signal) => {
+                const exitLabel = signal ? `signal ${signal}` : `code ${code ?? 'unknown'}`;
+                if (!resolved) {
+                    const suffix = combinedOutput.trim().length > 0 ? ` (${combinedOutput.trim()})` : '';
+                    failStart(`opencode server exited before startup (${exitLabel})${suffix}`);
+                    return;
+                }
+                this.baseUrl = null;
+                this.process = null;
+                if (!this.isStopping) {
+                    this.lastFailureReason = `opencode server exited unexpectedly (${exitLabel}).`;
+                }
+            });
+            setTimeout(() => {
+                if (!resolved) {
+                    processHandle.kill('SIGTERM');
+                    const suffix = combinedOutput.trim().length > 0 ? ` (${combinedOutput.trim()})` : '';
+                    failStart(`Timed out while waiting for opencode server startup${suffix}`);
+                }
+            }, 12_000);
+        });
+    }
+}
+export const createAgentService = (repositoryPath) => {
+    const resolvedRepositoryPath = resolve(repositoryPath);
+    const checkResult = spawnSync('opencode', ['--version'], {
+        encoding: 'utf8',
+    });
+    if (checkResult.error) {
+        const error = checkResult.error;
+        if (error.code === 'ENOENT') {
+            return new OpencodeUnavailableService('opencode is not available on PATH.');
+        }
+        return new OpencodeUnavailableService(`Failed to run opencode: ${toErrorMessage(error)}`);
+    }
+    if (checkResult.status !== 0) {
+        const stderr = checkResult.stderr?.trim() ?? '';
+        const stdout = checkResult.stdout?.trim() ?? '';
+        const reason = stderr || stdout || `opencode returned exit code ${checkResult.status}`;
+        return new OpencodeUnavailableService(`opencode is unavailable: ${reason}`);
+    }
+    return new OpencodeService(resolvedRepositoryPath);
+};
+//# sourceMappingURL=opencode.js.map