forge-server 0.1.0 → 0.1.1

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

@@ -1,364 +0,0 @@
-// 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

@@ -1,19 +0,0 @@
-{
-  "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"]
-}