forge-server 0.1.0

package/vscode-extension/src/edge-collector.ts

@@ -0,0 +1,320 @@
+// edge-collector.ts — Forge LSP Bridge
+// On file save, uses VS Code's built-in call hierarchy API to collect
+// type-resolved CALLS edges from the TypeScript Language Server.
+// Edges are batched and flushed to the forge server after a debounce period.
+
+import * as vscode from 'vscode';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface LspEdge {
+  from_file: string;
+  from_symbol: string;
+  to_file: string;
+  to_symbol: string;
+  edge_type: string;
+}
+
+export type FlushCallback = (edges: LspEdge[]) => Promise<void>;
+
+// ---------------------------------------------------------------------------
+// EdgeCollector
+// ---------------------------------------------------------------------------
+
+export class EdgeCollector {
+  private pendingEdges: LspEdge[] = [];
+  private debounceTimer: ReturnType<typeof setTimeout> | undefined;
+  private debounceMs: number;
+  private readonly flushCallback: FlushCallback;
+  private flushing = false;
+
+  constructor(debounceMs: number, flushCallback: FlushCallback) {
+    this.debounceMs = debounceMs;
+    this.flushCallback = flushCallback;
+  }
+
+  /**
+   * Update the debounce interval (e.g. when the user changes settings).
+   */
+  setDebounceMs(ms: number): void {
+    this.debounceMs = ms;
+  }
+
+  /**
+   * Collect call-hierarchy edges for all functions/methods in a saved document.
+   */
+  async collectFromDocument(document: vscode.TextDocument): Promise<void> {
+    const uri = document.uri;
+
+    // Get all document symbols to find functions, methods, constructors
+    const symbols = await this.getCallableSymbols(uri);
+
+    if (symbols.length === 0) {
+      return;
+    }
+
+    // For each callable symbol, prepare a call hierarchy and collect outgoing calls
+    for (const sym of symbols) {
+      try {
+        const edges = await this.collectOutgoingCalls(uri, sym);
+        if (edges.length > 0) {
+          this.pendingEdges.push(...edges);
+        }
+      } catch {
+        // Individual symbol failures are non-fatal — skip and continue.
+        // This can happen if the TS language server hasn't finished loading
+        // or if the symbol is in an unsupported position.
+      }
+    }
+
+    // Reset the debounce timer
+    this.scheduleFlush();
+  }
+
+  /**
+   * Force an immediate flush of all pending edges, regardless of debounce.
+   */
+  async flushNow(): Promise<void> {
+    this.cancelDebounce();
+    await this.doFlush();
+  }
+
+  // -------------------------------------------------------------------------
+  // Symbol discovery
+  // -------------------------------------------------------------------------
+
+  /**
+   * Flatten the document symbol tree and return only callable symbols
+   * (functions, methods, constructors).
+   */
+  private async getCallableSymbols(
+    uri: vscode.Uri,
+  ): Promise<FlatSymbol[]> {
+    let rawSymbols: vscode.DocumentSymbol[] | undefined;
+    try {
+      rawSymbols = await vscode.commands.executeCommand<vscode.DocumentSymbol[]>(
+        'vscode.executeDocumentSymbolProvider',
+        uri,
+      );
+    } catch {
+      return [];
+    }
+
+    if (!rawSymbols || rawSymbols.length === 0) {
+      return [];
+    }
+
+    const result: FlatSymbol[] = [];
+    this.flattenSymbols(rawSymbols, uri, result, undefined);
+    return result;
+  }
+
+  /**
+   * Recursively flatten nested DocumentSymbols into a flat list of callable
+   * symbols. Tracks parent name to build qualified symbol names like
+   * "ClassName.methodName".
+   */
+  private flattenSymbols(
+    symbols: vscode.DocumentSymbol[],
+    uri: vscode.Uri,
+    out: FlatSymbol[],
+    parentName: string | undefined,
+  ): void {
+    for (const sym of symbols) {
+      const qualifiedName = parentName
+        ? `${parentName}.${sym.name}`
+        : sym.name;
+
+      if (isCallable(sym.kind)) {
+        out.push({
+          name: qualifiedName,
+          kind: sym.kind,
+          range: sym.selectionRange,
+          uri,
+        });
+      }
+
+      // Recurse into children (e.g. methods inside a class)
+      if (sym.children && sym.children.length > 0) {
+        const nextParent =
+          sym.kind === vscode.SymbolKind.Class ||
+          sym.kind === vscode.SymbolKind.Interface ||
+          sym.kind === vscode.SymbolKind.Namespace ||
+          sym.kind === vscode.SymbolKind.Module
+            ? qualifiedName
+            : parentName;
+        this.flattenSymbols(sym.children, uri, out, nextParent);
+      }
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Call hierarchy collection
+  // -------------------------------------------------------------------------
+
+  /**
+   * For a single callable symbol, prepare a call hierarchy item and collect
+   * its outgoing calls. Returns LspEdge[] for "CALLS" relationships.
+   */
+  private async collectOutgoingCalls(
+    uri: vscode.Uri,
+    sym: FlatSymbol,
+  ): Promise<LspEdge[]> {
+    // Prepare call hierarchy at the symbol's selection position
+    const position = sym.range.start;
+    let callItems: vscode.CallHierarchyItem[] | undefined;
+
+    try {
+      callItems = await vscode.commands.executeCommand<vscode.CallHierarchyItem[]>(
+        'vscode.prepareCallHierarchy',
+        uri,
+        position,
+      );
+    } catch {
+      return [];
+    }
+
+    if (!callItems || callItems.length === 0) {
+      return [];
+    }
+
+    const edges: LspEdge[] = [];
+
+    for (const item of callItems) {
+      let outgoingCalls: vscode.CallHierarchyOutgoingCall[] | undefined;
+      try {
+        outgoingCalls = await vscode.commands.executeCommand<vscode.CallHierarchyOutgoingCall[]>(
+          'vscode.provideOutgoingCalls',
+          item,
+        );
+      } catch {
+        continue;
+      }
+
+      if (!outgoingCalls || outgoingCalls.length === 0) {
+        continue;
+      }
+
+      const fromFile = normalizeFilePath(item.uri.fsPath);
+      const fromSymbol = item.name;
+
+      for (const call of outgoingCalls) {
+        const toFile = normalizeFilePath(call.to.uri.fsPath);
+        const toSymbol = call.to.name;
+
+        // Skip self-references and node_modules
+        if (fromSymbol === toSymbol && fromFile === toFile) {
+          continue;
+        }
+        if (toFile.includes('node_modules')) {
+          continue;
+        }
+
+        edges.push({
+          from_file: fromFile,
+          from_symbol: fromSymbol,
+          to_file: toFile,
+          to_symbol: toSymbol,
+          edge_type: 'CALLS',
+        });
+      }
+    }
+
+    return edges;
+  }
+
+  // -------------------------------------------------------------------------
+  // Debounced flush
+  // -------------------------------------------------------------------------
+
+  private scheduleFlush(): void {
+    this.cancelDebounce();
+    this.debounceTimer = setTimeout(() => {
+      void this.doFlush();
+    }, this.debounceMs);
+  }
+
+  private cancelDebounce(): void {
+    if (this.debounceTimer !== undefined) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = undefined;
+    }
+  }
+
+  private async doFlush(): Promise<void> {
+    if (this.flushing) {
+      // Re-schedule if a flush is already in progress
+      this.scheduleFlush();
+      return;
+    }
+
+    if (this.pendingEdges.length === 0) {
+      return;
+    }
+
+    // Take ownership of the pending edges
+    const batch = this.pendingEdges;
+    this.pendingEdges = [];
+    this.flushing = true;
+
+    try {
+      // Deduplicate edges within the batch
+      const deduplicated = deduplicateEdges(batch);
+      await this.flushCallback(deduplicated);
+    } catch {
+      // If flush fails, re-queue the edges for the next attempt
+      this.pendingEdges.unshift(...batch);
+    } finally {
+      this.flushing = false;
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+interface FlatSymbol {
+  name: string;
+  kind: vscode.SymbolKind;
+  range: vscode.Range;
+  uri: vscode.Uri;
+}
+
+/**
+ * Returns true if the symbol kind represents something that can make calls.
+ */
+function isCallable(kind: vscode.SymbolKind): boolean {
+  return (
+    kind === vscode.SymbolKind.Function ||
+    kind === vscode.SymbolKind.Method ||
+    kind === vscode.SymbolKind.Constructor
+  );
+}
+
+/**
+ * Normalize file paths to use forward slashes for consistency.
+ */
+function normalizeFilePath(filePath: string): string {
+  return filePath.replace(/\\/g, '/');
+}
+
+/**
+ * Remove duplicate edges within a batch (same from/to file+symbol+type).
+ */
+function deduplicateEdges(edges: LspEdge[]): LspEdge[] {
+  const seen = new Set<string>();
+  const result: LspEdge[] = [];
+
+  for (const edge of edges) {
+    const key = `${edge.from_file}:${edge.from_symbol}->${edge.to_file}:${edge.to_symbol}:${edge.edge_type}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(edge);
+    }
+  }
+
+  return result;
+}

package/vscode-extension/src/extension.ts

@@ -0,0 +1,269 @@
+// extension.ts — Forge LSP Bridge
+// VS Code extension entry point. Hooks into file-save events for TS/JS files,
+// collects LSP-resolved call edges via the edge collector, and flushes them
+// to the dk-forge MCP server via the forge client.
+
+import * as vscode from 'vscode';
+import * as path from 'path';
+import * as fs from 'fs';
+import { EdgeCollector } from './edge-collector';
+import { ForgeClient } from './forge-client';
+
+// ---------------------------------------------------------------------------
+// State
+// ---------------------------------------------------------------------------
+
+let edgeCollector: EdgeCollector | undefined;
+let forgeClient: ForgeClient | undefined;
+let statusBarItem: vscode.StatusBarItem | undefined;
+let saveListener: vscode.Disposable | undefined;
+let enabled = true;
+let repoId = '';
+
+// ---------------------------------------------------------------------------
+// Activation
+// ---------------------------------------------------------------------------
+
+export async function activate(context: vscode.ExtensionContext): Promise<void> {
+  const config = vscode.workspace.getConfiguration('forge.lspBridge');
+  enabled = config.get<boolean>('enabled', true);
+
+  // Auto-detect repo ID from .forge/manifest.yaml if not configured
+  repoId = config.get<string>('repoId', '') || '';
+  if (!repoId) {
+    repoId = await detectRepoId();
+  }
+
+  const debounceMs = config.get<number>('debounceMs', 5000);
+  const mcpServerPath = config.get<string>('mcpServerPath', '') || '';
+
+  // Initialize forge MCP client
+  forgeClient = new ForgeClient(mcpServerPath);
+
+  // Initialize edge collector with flush callback
+  edgeCollector = new EdgeCollector(debounceMs, async (edges) => {
+    if (!forgeClient || !repoId) {
+      return;
+    }
+    try {
+      const result = await forgeClient.submitLspEdges(repoId, edges);
+      if (result && typeof result.accepted === 'number') {
+        log(`Flushed ${result.accepted} edges (${result.failed ?? 0} failed)`);
+      }
+    } catch (err) {
+      log(`Flush failed: ${String(err)}`);
+    }
+  });
+
+  // Status bar item
+  statusBarItem = vscode.window.createStatusBarItem(
+    vscode.StatusBarAlignment.Right,
+    50,
+  );
+  statusBarItem.command = 'forge.lspBridge.toggle';
+  updateStatusBar();
+  statusBarItem.show();
+  context.subscriptions.push(statusBarItem);
+
+  // Register the save listener
+  if (enabled) {
+    registerSaveListener(context);
+  }
+
+  // Register commands
+  context.subscriptions.push(
+    vscode.commands.registerCommand('forge.lspBridge.toggle', () => {
+      enabled = !enabled;
+      if (enabled) {
+        registerSaveListener(context);
+        log('Enabled');
+      } else {
+        disposeSaveListener();
+        log('Disabled');
+      }
+      updateStatusBar();
+    }),
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('forge.lspBridge.flush', async () => {
+      if (!edgeCollector) {
+        return;
+      }
+      await edgeCollector.flushNow();
+      log('Manual flush complete');
+    }),
+  );
+
+  // Watch for configuration changes
+  context.subscriptions.push(
+    vscode.workspace.onDidChangeConfiguration((e) => {
+      if (e.affectsConfiguration('forge.lspBridge')) {
+        const newConfig = vscode.workspace.getConfiguration('forge.lspBridge');
+        const newEnabled = newConfig.get<boolean>('enabled', true);
+        const newRepoId = newConfig.get<string>('repoId', '') || '';
+        const newDebounce = newConfig.get<number>('debounceMs', 5000);
+
+        if (newRepoId) {
+          repoId = newRepoId;
+        }
+
+        if (edgeCollector) {
+          edgeCollector.setDebounceMs(newDebounce);
+        }
+
+        if (newEnabled !== enabled) {
+          enabled = newEnabled;
+          if (enabled) {
+            registerSaveListener(context);
+          } else {
+            disposeSaveListener();
+          }
+          updateStatusBar();
+        }
+      }
+    }),
+  );
+
+  log(`Activated (repoId: ${repoId || '<none>'}, debounce: ${debounceMs}ms)`);
+}
+
+// ---------------------------------------------------------------------------
+// Deactivation
+// ---------------------------------------------------------------------------
+
+export async function deactivate(): Promise<void> {
+  disposeSaveListener();
+
+  // Flush any remaining edges
+  if (edgeCollector) {
+    try {
+      await edgeCollector.flushNow();
+    } catch {
+      // Ignore errors during deactivation
+    }
+  }
+
+  // Dispose the forge client (kills the child process)
+  if (forgeClient) {
+    forgeClient.dispose();
+    forgeClient = undefined;
+  }
+
+  if (statusBarItem) {
+    statusBarItem.dispose();
+    statusBarItem = undefined;
+  }
+
+  edgeCollector = undefined;
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+const SUPPORTED_LANGUAGES = new Set([
+  'typescript',
+  'javascript',
+  'typescriptreact',
+  'javascriptreact',
+]);
+
+function registerSaveListener(context: vscode.ExtensionContext): void {
+  disposeSaveListener();
+
+  saveListener = vscode.workspace.onDidSaveTextDocument(async (document) => {
+    if (!enabled || !edgeCollector) {
+      return;
+    }
+
+    if (!SUPPORTED_LANGUAGES.has(document.languageId)) {
+      return;
+    }
+
+    try {
+      await edgeCollector.collectFromDocument(document);
+    } catch (err) {
+      // Never let a collection error propagate to the save flow
+      log(`Collection error for ${document.fileName}: ${String(err)}`);
+    }
+  });
+
+  context.subscriptions.push(saveListener);
+}
+
+function disposeSaveListener(): void {
+  if (saveListener) {
+    saveListener.dispose();
+    saveListener = undefined;
+  }
+}
+
+function updateStatusBar(): void {
+  if (!statusBarItem) {
+    return;
+  }
+  if (enabled) {
+    statusBarItem.text = '$(symbol-method) Forge LSP';
+    statusBarItem.tooltip = 'Forge LSP Bridge: Active — click to toggle';
+    statusBarItem.backgroundColor = undefined;
+  } else {
+    statusBarItem.text = '$(circle-slash) Forge LSP';
+    statusBarItem.tooltip = 'Forge LSP Bridge: Disabled — click to toggle';
+    statusBarItem.backgroundColor = new vscode.ThemeColor(
+      'statusBarItem.warningBackground',
+    );
+  }
+}
+
+/**
+ * Detect the repo ID from .forge/manifest.yaml in the workspace root.
+ * Falls back to the workspace folder name, or empty string.
+ */
+async function detectRepoId(): Promise<string> {
+  const folders = vscode.workspace.workspaceFolders;
+  if (!folders || folders.length === 0) {
+    return '';
+  }
+
+  for (const folder of folders) {
+    const manifestPath = path.join(folder.uri.fsPath, '.forge', 'manifest.yaml');
+    try {
+      if (fs.existsSync(manifestPath)) {
+        const content = fs.readFileSync(manifestPath, 'utf8');
+        // Simple YAML parsing — look for "name: <value>" line
+        const nameMatch = content.match(/^name:\s*(.+)$/m);
+        if (nameMatch && nameMatch[1]) {
+          const name = nameMatch[1].trim();
+          if (name) {
+            return name;
+          }
+        }
+        // Check for repo_id_override
+        const overrideMatch = content.match(/^repo_id_override:\s*(.+)$/m);
+        if (overrideMatch && overrideMatch[1]) {
+          const override = overrideMatch[1].trim();
+          if (override && override !== 'null') {
+            return override;
+          }
+        }
+      }
+    } catch {
+      // Silently continue if the manifest can't be read
+    }
+  }
+
+  // Fallback: use the first workspace folder name
+  return folders[0]?.name ?? '';
+}
+
+// ---------------------------------------------------------------------------
+// Logging
+// ---------------------------------------------------------------------------
+
+const outputChannel = vscode.window.createOutputChannel('Forge LSP Bridge');
+
+function log(message: string): void {
+  const timestamp = new Date().toISOString();
+  outputChannel.appendLine(`[${timestamp}] ${message}`);
+}