forge-server 0.1.0

package/vscode-extension/src/forge-client.ts

@@ -0,0 +1,364 @@
+// forge-client.ts — Forge LSP Bridge
+// MCP stdio client that spawns the dk-forge-server as a child process and
+// communicates via JSON-RPC 2.0 over stdio with Content-Length framing.
+//
+// This client is purpose-built for submitting LSP edges via the
+// `submit_lsp_edges` tool. It lazily spawns the server on first use and
+// reuses the connection for subsequent calls.
+
+import { spawn, ChildProcess } from 'child_process';
+import * as path from 'path';
+import type { LspEdge } from './edge-collector';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+interface JsonRpcRequest {
+  jsonrpc: '2.0';
+  id: number;
+  method: string;
+  params?: unknown;
+}
+
+interface JsonRpcResponse {
+  jsonrpc: '2.0';
+  id: number;
+  result?: unknown;
+  error?: { code: number; message: string; data?: unknown };
+}
+
+interface ToolCallResult {
+  content?: Array<{ type: string; text: string }>;
+  isError?: boolean;
+}
+
+interface SubmitLspEdgesResult {
+  accepted: number;
+  failed: number;
+  errors?: string[];
+}
+
+// ---------------------------------------------------------------------------
+// ForgeClient
+// ---------------------------------------------------------------------------
+
+export class ForgeClient {
+  private process: ChildProcess | undefined;
+  private readonly serverPath: string;
+  private nextId = 1;
+  private responseBuffer = '';
+  private pendingRequests = new Map<number, {
+    resolve: (value: JsonRpcResponse) => void;
+    reject: (reason: Error) => void;
+    timer: ReturnType<typeof setTimeout>;
+  }>();
+  private initialized = false;
+  private initializing: Promise<void> | undefined;
+  private disposed = false;
+
+  /**
+   * @param serverPath Absolute path to the dk-forge-server entry point.
+   *   If empty, resolves to the bundled dist/index.js relative to this extension.
+   */
+  constructor(serverPath: string) {
+    if (serverPath) {
+      this.serverPath = serverPath;
+    } else {
+      // Default: assume forge-pipeline-server is a sibling or parent checkout
+      // The extension is at vscode-extension/ inside the server repo, so:
+      // ../dist/index.js is the compiled server entry
+      this.serverPath = path.resolve(__dirname, '..', '..', 'dist', 'index.js');
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+
+  /**
+   * Submit a batch of LSP edges to the forge server's submit_lsp_edges tool.
+   */
+  async submitLspEdges(
+    repoId: string,
+    edges: LspEdge[],
+  ): Promise<SubmitLspEdgesResult | undefined> {
+    if (this.disposed) {
+      return undefined;
+    }
+
+    if (edges.length === 0) {
+      return { accepted: 0, failed: 0 };
+    }
+
+    await this.ensureInitialized();
+
+    // MCP tool call: tools/call with the tool name and arguments
+    const response = await this.sendRequest('tools/call', {
+      name: 'submit_lsp_edges',
+      arguments: {
+        repo_id: repoId,
+        edges,
+      },
+    });
+
+    if (response.error) {
+      throw new Error(
+        `MCP error ${response.error.code}: ${response.error.message}`,
+      );
+    }
+
+    // Parse the tool result — MCP wraps tool output in content blocks
+    const toolResult = response.result as ToolCallResult | undefined;
+    if (toolResult?.content && toolResult.content.length > 0) {
+      const firstContent = toolResult.content[0];
+      if (firstContent && firstContent.type === 'text') {
+        try {
+          return JSON.parse(firstContent.text) as SubmitLspEdgesResult;
+        } catch {
+          return undefined;
+        }
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Dispose the client and kill the child process.
+   */
+  dispose(): void {
+    this.disposed = true;
+    this.clearAllPending('Client disposed');
+    this.killProcess();
+  }
+
+  // -------------------------------------------------------------------------
+  // Process lifecycle
+  // -------------------------------------------------------------------------
+
+  private async ensureInitialized(): Promise<void> {
+    if (this.initialized && this.process && !this.process.killed) {
+      return;
+    }
+
+    // Prevent concurrent initialization
+    if (this.initializing) {
+      await this.initializing;
+      return;
+    }
+
+    this.initializing = this.doInitialize();
+    try {
+      await this.initializing;
+    } finally {
+      this.initializing = undefined;
+    }
+  }
+
+  private async doInitialize(): Promise<void> {
+    this.killProcess();
+    this.initialized = false;
+
+    // Spawn the forge server as a child process on stdio
+    this.process = spawn('node', [this.serverPath], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: {
+        ...process.env,
+        // Prevent forge server from polluting stdout with log messages
+        FORGE_LOG_LEVEL: 'warn',
+      },
+      windowsHide: true,
+    });
+
+    // Wire up stdout for JSON-RPC responses
+    this.process.stdout?.on('data', (chunk: Buffer) => {
+      this.onData(chunk.toString('utf8'));
+    });
+
+    // Log stderr but don't treat it as fatal
+    this.process.stderr?.on('data', (chunk: Buffer) => {
+      // stderr output from the forge server is informational
+      void chunk; // suppress unused variable
+    });
+
+    this.process.on('error', (err) => {
+      this.clearAllPending(`Process error: ${err.message}`);
+      this.initialized = false;
+    });
+
+    this.process.on('exit', (code) => {
+      this.clearAllPending(`Process exited with code ${String(code)}`);
+      this.initialized = false;
+    });
+
+    // Send the MCP initialize handshake
+    const initResponse = await this.sendRequest('initialize', {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: {
+        name: 'forge-lsp-bridge',
+        version: '0.1.0',
+      },
+    });
+
+    if (initResponse.error) {
+      throw new Error(
+        `MCP initialize failed: ${initResponse.error.message}`,
+      );
+    }
+
+    // Send initialized notification (no response expected)
+    this.sendNotification('notifications/initialized', {});
+
+    this.initialized = true;
+  }
+
+  private killProcess(): void {
+    if (this.process) {
+      try {
+        this.process.kill('SIGTERM');
+      } catch {
+        // Process may already be dead
+      }
+      this.process = undefined;
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // JSON-RPC over stdio with Content-Length framing
+  // -------------------------------------------------------------------------
+
+  private sendRequest(method: string, params?: unknown): Promise<JsonRpcResponse> {
+    return new Promise((resolve, reject) => {
+      if (!this.process || !this.process.stdin || this.process.killed) {
+        reject(new Error('Forge server process is not running'));
+        return;
+      }
+
+      const id = this.nextId++;
+      const request: JsonRpcRequest = {
+        jsonrpc: '2.0',
+        id,
+        method,
+        params,
+      };
+
+      const body = JSON.stringify(request);
+      const header = `Content-Length: ${Buffer.byteLength(body, 'utf8')}\r\n\r\n`;
+
+      // Timeout after 30 seconds
+      const timer = setTimeout(() => {
+        const pending = this.pendingRequests.get(id);
+        if (pending) {
+          this.pendingRequests.delete(id);
+          pending.reject(new Error(`Request ${method} timed out after 30s`));
+        }
+      }, 30_000);
+
+      this.pendingRequests.set(id, { resolve, reject, timer });
+
+      try {
+        this.process.stdin.write(header + body, 'utf8');
+      } catch (err) {
+        this.pendingRequests.delete(id);
+        clearTimeout(timer);
+        reject(new Error(`Failed to write to forge server: ${String(err)}`));
+      }
+    });
+  }
+
+  private sendNotification(method: string, params?: unknown): void {
+    if (!this.process || !this.process.stdin || this.process.killed) {
+      return;
+    }
+
+    const notification = {
+      jsonrpc: '2.0' as const,
+      method,
+      params,
+    };
+
+    const body = JSON.stringify(notification);
+    const header = `Content-Length: ${Buffer.byteLength(body, 'utf8')}\r\n\r\n`;
+
+    try {
+      this.process.stdin.write(header + body, 'utf8');
+    } catch {
+      // Notifications are fire-and-forget
+    }
+  }
+
+  /**
+   * Handle incoming data from the server's stdout.
+   * Parses Content-Length framed JSON-RPC messages.
+   */
+  private onData(chunk: string): void {
+    this.responseBuffer += chunk;
+    this.processBuffer();
+  }
+
+  private processBuffer(): void {
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      // Look for Content-Length header
+      const headerEnd = this.responseBuffer.indexOf('\r\n\r\n');
+      if (headerEnd === -1) {
+        break;
+      }
+
+      const headerSection = this.responseBuffer.substring(0, headerEnd);
+      const contentLengthMatch = headerSection.match(/Content-Length:\s*(\d+)/i);
+      if (!contentLengthMatch || !contentLengthMatch[1]) {
+        // Malformed header — skip past the double CRLF and try again
+        this.responseBuffer = this.responseBuffer.substring(headerEnd + 4);
+        continue;
+      }
+
+      const contentLength = parseInt(contentLengthMatch[1], 10);
+      const bodyStart = headerEnd + 4;
+      const bodyEnd = bodyStart + contentLength;
+
+      if (this.responseBuffer.length < bodyEnd) {
+        // Not enough data yet — wait for more
+        break;
+      }
+
+      const body = this.responseBuffer.substring(bodyStart, bodyEnd);
+      this.responseBuffer = this.responseBuffer.substring(bodyEnd);
+
+      try {
+        const message = JSON.parse(body) as JsonRpcResponse;
+        this.handleResponse(message);
+      } catch {
+        // Malformed JSON — skip this message
+      }
+    }
+  }
+
+  private handleResponse(message: JsonRpcResponse): void {
+    // Only handle responses (messages with an id and no method)
+    if (message.id === undefined || message.id === null) {
+      // This is a notification from the server — ignore
+      return;
+    }
+
+    const pending = this.pendingRequests.get(message.id);
+    if (!pending) {
+      // Response for an unknown or timed-out request — discard
+      return;
+    }
+
+    this.pendingRequests.delete(message.id);
+    clearTimeout(pending.timer);
+    pending.resolve(message);
+  }
+
+  private clearAllPending(reason: string): void {
+    for (const [id, pending] of this.pendingRequests) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error(reason));
+      this.pendingRequests.delete(id);
+    }
+  }
+}

package/vscode-extension/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "outDir": "out",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "sourceMap": true,
+    "declaration": false,
+    "noUncheckedIndexedAccess": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "out"]
+}