byterover-cli 1.0.5 → 1.2.0

package/dist/infra/mcp/tools/brv-curate-tool.d.ts

@@ -0,0 +1,23 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { ITransportClient } from '../../../core/interfaces/transport/index.js';
+export declare const BrvCurateInputSchema: z.ZodObject<{
+    context: z.ZodString;
+    files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    context: string;
+    files?: string[] | undefined;
+}, {
+    context: string;
+    files?: string[] | undefined;
+}>;
+/**
+ * Registers the brv-curate tool with the MCP server.
+ *
+ * This tool allows coding agents to store context to the ByteRover context tree.
+ * Use it to save patterns, architectural decisions, error solutions, or insights.
+ *
+ * Uses fire-and-forget pattern: returns immediately after queueing the task.
+ * The curation is processed asynchronously by the ByteRover agent.
+ */
+export declare function registerBrvCurateTool(server: McpServer, getClient: () => ITransportClient | undefined, getWorkingDirectory: () => string): void;

package/dist/infra/mcp/tools/brv-curate-tool.js

@@ -0,0 +1,68 @@
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+export const BrvCurateInputSchema = z.object({
+    context: z.string().describe('Knowledge to store: patterns, decisions, errors, or insights about the codebase'),
+    files: z
+        .array(z.string())
+        .max(5)
+        .optional()
+        .describe('Optional file paths with critical context to include (max 5 files)'),
+});
+/**
+ * Registers the brv-curate tool with the MCP server.
+ *
+ * This tool allows coding agents to store context to the ByteRover context tree.
+ * Use it to save patterns, architectural decisions, error solutions, or insights.
+ *
+ * Uses fire-and-forget pattern: returns immediately after queueing the task.
+ * The curation is processed asynchronously by the ByteRover agent.
+ */
+export function registerBrvCurateTool(server, getClient, getWorkingDirectory) {
+    server.registerTool('brv-curate', {
+        description: 'Store context to the ByteRover context tree. Save patterns, decisions, or insights.',
+        inputSchema: BrvCurateInputSchema,
+        title: 'ByteRover Curate',
+    }, async ({ context, files }) => {
+        const client = getClient();
+        if (!client) {
+            return {
+                content: [{ text: 'Error: Not connected to ByteRover instance. Run "brv" first.', type: 'text' }],
+                isError: true,
+            };
+        }
+        // Check connection state before making request
+        const state = client.getState();
+        if (state !== 'connected') {
+            return {
+                content: [{ text: `Error: Socket not connected. Current state: ${state}. Ensure "brv" is running.`, type: 'text' }],
+                isError: true,
+            };
+        }
+        try {
+            const taskId = randomUUID();
+            // Create task via transport (same pattern as brv curate command)
+            await client.request('task:create', {
+                clientCwd: getWorkingDirectory(),
+                content: context,
+                taskId,
+                type: 'curate',
+                ...(files?.length ? { files } : {}),
+            });
+            // Fire-and-forget: return immediately after task is queued
+            // Curation is processed asynchronously by the ByteRover agent
+            return {
+                content: [{
+                        text: `✓ Context queued for curation (taskId: ${taskId}). The curation will be processed asynchronously.`,
+                        type: 'text',
+                    }],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{ text: `Error: ${message}`, type: 'text' }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/infra/mcp/tools/brv-query-tool.d.ts

@@ -0,0 +1,17 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { ITransportClient } from '../../../core/interfaces/transport/index.js';
+export declare const BrvQueryInputSchema: z.ZodObject<{
+    query: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+}, {
+    query: string;
+}>;
+/**
+ * Registers the brv-query tool with the MCP server.
+ *
+ * This tool allows coding agents to query the ByteRover context tree
+ * for patterns, decisions, implementation details, or any stored knowledge.
+ */
+export declare function registerBrvQueryTool(server: McpServer, getClient: () => ITransportClient | undefined, getWorkingDirectory: () => string): void;

package/dist/infra/mcp/tools/brv-query-tool.js

@@ -0,0 +1,68 @@
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+import { waitForTaskResult } from './task-result-waiter.js';
+export const BrvQueryInputSchema = z.object({
+    query: z.string().describe('Natural language question about the codebase or project'),
+});
+/**
+ * Registers the brv-query tool with the MCP server.
+ *
+ * This tool allows coding agents to query the ByteRover context tree
+ * for patterns, decisions, implementation details, or any stored knowledge.
+ */
+export function registerBrvQueryTool(server, getClient, getWorkingDirectory) {
+    server.registerTool('brv-query', {
+        description: 'Query the ByteRover context tree for patterns, decisions, or implementation details.',
+        inputSchema: BrvQueryInputSchema,
+        title: 'ByteRover Query',
+    }, async ({ query }) => {
+        const timestamp = new Date().toISOString();
+        process.stderr.write(`[brv-mcp] [${timestamp}] brv-query tool called with query: ${query.slice(0, 50)}...\n`);
+        const client = getClient();
+        process.stderr.write(`[brv-mcp] [${timestamp}] Client exists: ${client}\n`);
+        if (!client) {
+            process.stderr.write(`[brv-mcp] [${timestamp}] ERROR: Client is undefined\n`);
+            return {
+                content: [{ text: 'Error: Not connected to ByteRover instance. Run "brv" first.', type: 'text' }],
+                isError: true,
+            };
+        }
+        // Check connection state before making request
+        const state = client.getState();
+        process.stderr.write(`[brv-mcp] [${timestamp}] Client state: ${state}, Client ID: ${client.getClientId()}\n`);
+        if (state !== 'connected') {
+            process.stderr.write(`[brv-mcp] [${timestamp}] ERROR: Socket not connected\n`);
+            return {
+                content: [
+                    {
+                        text: `Error: Socket not connected. Current state: ${state}. Ensure "brv" is running.`,
+                        type: 'text',
+                    },
+                ],
+                isError: true,
+            };
+        }
+        try {
+            const taskId = randomUUID();
+            // Create task via transport (same pattern as brv query command)
+            await client.request('task:create', {
+                clientCwd: getWorkingDirectory(),
+                content: query,
+                taskId,
+                type: 'query',
+            });
+            // Wait for task completion and return result
+            const result = await waitForTaskResult(client, taskId);
+            return {
+                content: [{ text: result, type: 'text' }],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{ text: `Error: ${message}`, type: 'text' }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/infra/mcp/tools/index.d.ts

@@ -0,0 +1,3 @@
+export { registerBrvCurateTool } from './brv-curate-tool.js';
+export { registerBrvQueryTool } from './brv-query-tool.js';
+export { waitForTaskResult } from './task-result-waiter.js';

package/dist/infra/mcp/tools/index.js

@@ -0,0 +1,3 @@
+export { registerBrvCurateTool } from './brv-curate-tool.js';
+export { registerBrvQueryTool } from './brv-query-tool.js';
+export { waitForTaskResult } from './task-result-waiter.js';

package/dist/infra/mcp/tools/task-result-waiter.d.ts

@@ -0,0 +1,30 @@
+import type { ITransportClient } from '../../../core/interfaces/transport/index.js';
+export interface TaskCompletedPayload {
+    result: string;
+    taskId: string;
+}
+export interface TaskErrorPayload {
+    error: {
+        code?: string;
+        details?: Record<string, unknown>;
+        message: string;
+        name: string;
+    };
+    taskId: string;
+}
+export interface LlmResponsePayload {
+    content: string;
+    taskId: string;
+}
+/**
+ * Waits for a task to complete and returns the result.
+ *
+ * Unlike the fire-and-forget pattern used by `brv curate`, MCP tools need
+ * to wait for the task to finish and return the result to the coding agent.
+ *
+ * This function listens for:
+ * - llmservice:response: Captures the LLM's text response
+ * - task:completed: Task finished successfully
+ * - task:error: Task failed with an error
+ */
+export declare function waitForTaskResult(client: ITransportClient, taskId: string, timeoutMs?: number): Promise<string>;

package/dist/infra/mcp/tools/task-result-waiter.js

@@ -0,0 +1,56 @@
+/**
+ * Waits for a task to complete and returns the result.
+ *
+ * Unlike the fire-and-forget pattern used by `brv curate`, MCP tools need
+ * to wait for the task to finish and return the result to the coding agent.
+ *
+ * This function listens for:
+ * - llmservice:response: Captures the LLM's text response
+ * - task:completed: Task finished successfully
+ * - task:error: Task failed with an error
+ */
+export async function waitForTaskResult(client, taskId, timeoutMs = 120_000) {
+    return new Promise((resolve, reject) => {
+        let result = '';
+        let completed = false;
+        const unsubscribers = [];
+        const cleanup = () => {
+            clearTimeout(timeout);
+            for (const unsub of unsubscribers) {
+                unsub();
+            }
+        };
+        const timeout = setTimeout(() => {
+            if (!completed) {
+                completed = true;
+                cleanup();
+                reject(new Error(`Task timeout after ${timeoutMs}ms`));
+            }
+        }, timeoutMs);
+        // Set up all event listeners
+        unsubscribers.push(
+        // Listen for LLM response content
+        client.on('llmservice:response', (payload) => {
+            if (payload.taskId === taskId && payload.content) {
+                result = payload.content;
+            }
+        }), 
+        // Listen for task completion
+        client.on('task:completed', (payload) => {
+            if (payload.taskId === taskId && !completed) {
+                completed = true;
+                cleanup();
+                // Use the result from the event if available, otherwise use accumulated result
+                resolve(payload.result || result);
+            }
+        }), 
+        // Listen for task error
+        client.on('task:error', (payload) => {
+            if (payload.taskId === taskId && !completed) {
+                completed = true;
+                cleanup();
+                reject(new Error(payload.error.message));
+            }
+        }));
+    });
+}

package/dist/infra/process/agent-worker.d.ts

@@ -9,8 +9,8 @@
  * - NO Socket.IO server (Transport is the only server)
  *
  * IPC messages:
- * - Receives: 'ping', 'shutdown'
- * - Sends: 'ready', 'pong', 'stopped', 'error'
+ * - Receives: 'ping', 'shutdown', 'health-check'
+ * - Sends: 'ready', 'pong', 'stopped', 'error', 'health-check-result'
  *
  * Socket.IO events (as client):
  * - Sends: 'agent:register' (identify as Agent)