forge-server 0.1.0 → 0.1.1

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

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

@@ -1,269 +0,0 @@
-// 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}`);
-}