github-to-mcp-monorepo 1.0.0

package/apps/vscode/src/utils/storage.ts

@@ -0,0 +1,87 @@
+/**
+ * @fileoverview Storage utility for conversion history
+ * @copyright Copyright (c) 2024-2026 nirholas
+ * @license MIT
+ */
+
+import * as vscode from 'vscode';
+
+export interface ConversionResult {
+  id: string;
+  repoUrl: string;
+  repoName: string;
+  toolCount: number;
+  timestamp: string;
+  classification?: {
+    type: string;
+    confidence: number;
+    indicators: string[];
+  };
+  code?: string;
+  tools?: Array<{
+    name: string;
+    description: string;
+  }>;
+}
+
+const HISTORY_KEY = 'github-to-mcp.history';
+
+export class StorageService {
+  private context: vscode.ExtensionContext;
+
+  constructor(context: vscode.ExtensionContext) {
+    this.context = context;
+  }
+
+  /**
+   * Get conversion history
+   */
+  getHistory(): ConversionResult[] {
+    return this.context.globalState.get<ConversionResult[]>(HISTORY_KEY) || [];
+  }
+
+  /**
+   * Add a conversion result to history
+   */
+  addToHistory(result: ConversionResult): void {
+    const history = this.getHistory();
+    
+    // Add to beginning
+    history.unshift(result);
+
+    // Get limit from config
+    const config = vscode.workspace.getConfiguration('github-to-mcp');
+    const limit = config.get<number>('historyLimit') || 20;
+
+    // Trim to limit
+    if (history.length > limit) {
+      history.length = limit;
+    }
+
+    this.context.globalState.update(HISTORY_KEY, history);
+  }
+
+  /**
+   * Remove a specific item from history
+   */
+  removeFromHistory(id: string): void {
+    const history = this.getHistory();
+    const filtered = history.filter(item => item.id !== id);
+    this.context.globalState.update(HISTORY_KEY, filtered);
+  }
+
+  /**
+   * Clear all history
+   */
+  clearHistory(): void {
+    this.context.globalState.update(HISTORY_KEY, []);
+  }
+
+  /**
+   * Get a specific conversion by ID
+   */
+  getConversion(id: string): ConversionResult | undefined {
+    const history = this.getHistory();
+    return history.find(item => item.id === id);
+  }
+}

package/apps/vscode/src/views/McpServersTreeView.ts

@@ -0,0 +1,160 @@
+/**
+ * @fileoverview Tree view provider for MCP servers
+ * @copyright Copyright (c) 2024-2026 nirholas
+ * @license MIT
+ */
+
+import * as vscode from 'vscode';
+import { StorageService, ConversionResult } from '../utils/storage';
+
+type McpServerTreeItem = McpServerItem | McpToolItem | EmptyItem;
+
+/**
+ * Tree data provider for MCP servers view
+ */
+export class McpServersTreeView implements vscode.TreeDataProvider<McpServerTreeItem> {
+  private _onDidChangeTreeData: vscode.EventEmitter<McpServerTreeItem | undefined | null | void> = 
+    new vscode.EventEmitter<McpServerTreeItem | undefined | null | void>();
+  readonly onDidChangeTreeData: vscode.Event<McpServerTreeItem | undefined | null | void> = 
+    this._onDidChangeTreeData.event;
+
+  constructor(private storage: StorageService) {}
+
+  /**
+   * Refresh the tree view
+   */
+  refresh(): void {
+    this._onDidChangeTreeData.fire();
+  }
+
+  /**
+   * Get tree item representation
+   */
+  getTreeItem(element: McpServerTreeItem): vscode.TreeItem {
+    return element;
+  }
+
+  /**
+   * Get children for tree node
+   */
+  getChildren(element?: McpServerTreeItem): McpServerTreeItem[] {
+    if (!element) {
+      // Root level - show all servers
+      const history = this.storage.getHistory();
+      
+      if (history.length === 0) {
+        return [new EmptyItem('No MCP servers yet', 'Convert a repository to get started')];
+      }
+
+      return history.map(item => new McpServerItem(item));
+    }
+
+    if (element instanceof McpServerItem) {
+      // Show tools under each server
+      const tools = element.result.tools || [];
+      
+      if (tools.length === 0) {
+        return [new EmptyItem('No tools', 'This server has no tools')];
+      }
+
+      return tools.map(tool => new McpToolItem(tool, element.result));
+    }
+
+    return [];
+  }
+
+  /**
+   * Get parent of element (for reveal)
+   */
+  getParent(element: McpServerTreeItem): McpServerTreeItem | undefined {
+    if (element instanceof McpToolItem) {
+      const history = this.storage.getHistory();
+      const server = history.find(h => h.id === element.serverId);
+      if (server) {
+        return new McpServerItem(server);
+      }
+    }
+    return undefined;
+  }
+}
+
+/**
+ * Tree item for an MCP server
+ */
+export class McpServerItem extends vscode.TreeItem {
+  public readonly result: ConversionResult;
+
+  constructor(result: ConversionResult) {
+    super(result.repoName, vscode.TreeItemCollapsibleState.Collapsed);
+    
+    this.result = result;
+    this.description = `${result.toolCount} tools`;
+    
+    const date = new Date(result.timestamp);
+    const formattedDate = date.toLocaleDateString() + ' ' + date.toLocaleTimeString();
+    
+    this.tooltip = new vscode.MarkdownString();
+    this.tooltip.appendMarkdown(`### ${result.repoName}\n\n`);
+    this.tooltip.appendMarkdown(`**Tools:** ${result.toolCount}\n\n`);
+    if (result.classification) {
+      this.tooltip.appendMarkdown(`**Type:** ${result.classification.type}\n\n`);
+      this.tooltip.appendMarkdown(`**Confidence:** ${Math.round(result.classification.confidence * 100)}%\n\n`);
+    }
+    this.tooltip.appendMarkdown(`**Converted:** ${formattedDate}\n\n`);
+    this.tooltip.appendMarkdown(`[Open Repository](${result.repoUrl})`);
+    this.tooltip.isTrusted = true;
+    
+    this.iconPath = new vscode.ThemeIcon('server', new vscode.ThemeColor('charts.green'));
+    this.contextValue = 'mcpServer';
+
+    // Command on click
+    this.command = {
+      command: 'github-to-mcp.viewDetails',
+      title: 'View Details',
+      arguments: [result]
+    };
+  }
+}
+
+/**
+ * Tree item for an MCP tool
+ */
+export class McpToolItem extends vscode.TreeItem {
+  public readonly serverId: string;
+
+  constructor(
+    tool: { name: string; description: string },
+    server: ConversionResult
+  ) {
+    super(tool.name, vscode.TreeItemCollapsibleState.None);
+    
+    this.serverId = server.id;
+    this.description = tool.description.substring(0, 50) + (tool.description.length > 50 ? '...' : '');
+    
+    this.tooltip = new vscode.MarkdownString();
+    this.tooltip.appendMarkdown(`### ${tool.name}\n\n`);
+    this.tooltip.appendMarkdown(tool.description);
+    this.tooltip.isTrusted = true;
+    
+    this.iconPath = new vscode.ThemeIcon('symbol-method', new vscode.ThemeColor('charts.blue'));
+    this.contextValue = 'mcpTool';
+
+    // Command to show tool details
+    this.command = {
+      command: 'github-to-mcp.showToolDetails',
+      title: 'Show Tool Details',
+      arguments: [tool, server]
+    };
+  }
+}
+
+/**
+ * Empty placeholder item
+ */
+class EmptyItem extends vscode.TreeItem {
+  constructor(label: string, description?: string) {
+    super(label, vscode.TreeItemCollapsibleState.None);
+    this.description = description;
+    this.iconPath = new vscode.ThemeIcon('info');
+  }
+}

package/apps/vscode/src/views/OutputChannelView.ts

@@ -0,0 +1,195 @@
+/**
+ * @fileoverview Dedicated output channel for extension logs
+ * @copyright Copyright (c) 2024-2026 nirholas
+ * @license MIT
+ */
+
+import * as vscode from 'vscode';
+
+type LogLevel = 'info' | 'warn' | 'error' | 'debug';
+
+/**
+ * Output channel manager for extension logging
+ */
+export class OutputChannelView {
+  private static instance: OutputChannelView;
+  private channel: vscode.OutputChannel;
+  private logLevel: LogLevel = 'info';
+
+  private constructor() {
+    this.channel = vscode.window.createOutputChannel('GitHub to MCP', { log: true });
+  }
+
+  /**
+   * Get singleton instance
+   */
+  static getInstance(): OutputChannelView {
+    if (!OutputChannelView.instance) {
+      OutputChannelView.instance = new OutputChannelView();
+    }
+    return OutputChannelView.instance;
+  }
+
+  /**
+   * Set the minimum log level
+   */
+  setLogLevel(level: LogLevel): void {
+    this.logLevel = level;
+    this.info(`Log level set to: ${level}`);
+  }
+
+  /**
+   * Log info message
+   */
+  info(message: string, ...args: unknown[]): void {
+    this.log('info', message, ...args);
+  }
+
+  /**
+   * Log warning message
+   */
+  warn(message: string, ...args: unknown[]): void {
+    this.log('warn', message, ...args);
+  }
+
+  /**
+   * Log error message
+   */
+  error(message: string, error?: Error, ...args: unknown[]): void {
+    this.log('error', message, ...args);
+    if (error) {
+      this.channel.appendLine(`  Stack: ${error.stack || 'No stack trace'}`);
+    }
+  }
+
+  /**
+   * Log debug message
+   */
+  debug(message: string, ...args: unknown[]): void {
+    if (this.shouldLog('debug')) {
+      this.log('debug', message, ...args);
+    }
+  }
+
+  /**
+   * Log a message with level
+   */
+  private log(level: LogLevel, message: string, ...args: unknown[]): void {
+    if (!this.shouldLog(level)) {
+      return;
+    }
+
+    const timestamp = new Date().toISOString();
+    const levelIcon = this.getLevelIcon(level);
+    const formattedArgs = args.length > 0 ? ' ' + JSON.stringify(args) : '';
+    
+    this.channel.appendLine(`[${timestamp}] ${levelIcon} ${message}${formattedArgs}`);
+  }
+
+  /**
+   * Check if message should be logged based on level
+   */
+  private shouldLog(level: LogLevel): boolean {
+    const levels: LogLevel[] = ['debug', 'info', 'warn', 'error'];
+    const currentLevelIndex = levels.indexOf(this.logLevel);
+    const messageLevelIndex = levels.indexOf(level);
+    return messageLevelIndex >= currentLevelIndex;
+  }
+
+  /**
+   * Get icon for log level
+   */
+  private getLevelIcon(level: LogLevel): string {
+    switch (level) {
+      case 'debug': return '🔍';
+      case 'info': return 'ℹ️';
+      case 'warn': return '⚠️';
+      case 'error': return '❌';
+    }
+  }
+
+  /**
+   * Show the output channel
+   */
+  show(): void {
+    this.channel.show();
+  }
+
+  /**
+   * Hide the output channel
+   */
+  hide(): void {
+    this.channel.hide();
+  }
+
+  /**
+   * Clear the output channel
+   */
+  clear(): void {
+    this.channel.clear();
+    this.info('Output cleared');
+  }
+
+  /**
+   * Log conversion start
+   */
+  logConversionStart(repoUrl: string): void {
+    this.info('═'.repeat(50));
+    this.info(`Starting conversion for: ${repoUrl}`);
+    this.info('═'.repeat(50));
+  }
+
+  /**
+   * Log conversion progress
+   */
+  logConversionProgress(step: string, details?: string): void {
+    this.info(`  → ${step}${details ? ': ' + details : ''}`);
+  }
+
+  /**
+   * Log conversion success
+   */
+  logConversionSuccess(repoName: string, toolCount: number): void {
+    this.info('✅ Conversion completed successfully!');
+    this.info(`  Repository: ${repoName}`);
+    this.info(`  Tools found: ${toolCount}`);
+    this.info('─'.repeat(50));
+  }
+
+  /**
+   * Log conversion failure
+   */
+  logConversionFailure(repoUrl: string, error: Error): void {
+    this.error(`❌ Conversion failed for: ${repoUrl}`, error);
+    this.info('─'.repeat(50));
+  }
+
+  /**
+   * Log tool extraction
+   */
+  logToolExtracted(toolName: string, description: string): void {
+    this.debug(`  📦 Extracted tool: ${toolName}`);
+    this.debug(`     ${description.substring(0, 60)}${description.length > 60 ? '...' : ''}`);
+  }
+
+  /**
+   * Log configuration change
+   */
+  logConfigChange(setting: string, value: unknown): void {
+    this.info(`Configuration changed: ${setting} = ${JSON.stringify(value)}`);
+  }
+
+  /**
+   * Dispose the output channel
+   */
+  dispose(): void {
+    this.channel.dispose();
+  }
+}
+
+/**
+ * Get the global output channel instance
+ */
+export function getOutputChannel(): OutputChannelView {
+  return OutputChannelView.getInstance();
+}

package/apps/vscode/src/views/StatusBarItem.ts

@@ -0,0 +1,251 @@
+/**
+ * @fileoverview Status bar item for showing conversion progress
+ * @copyright Copyright (c) 2024-2026 nirholas
+ * @license MIT
+ */
+
+import * as vscode from 'vscode';
+import { isCurrentWorkspaceGitHubRepo } from '../commands/convertCurrentRepo';
+
+type StatusBarState = 'idle' | 'loading' | 'success' | 'error';
+
+/**
+ * Status bar item manager for the extension
+ */
+export class StatusBarItem {
+  private item: vscode.StatusBarItem;
+  private state: StatusBarState = 'idle';
+  private progressInterval: NodeJS.Timeout | null = null;
+  private progressDots = 0;
+
+  constructor(private context: vscode.ExtensionContext) {
+    this.item = vscode.window.createStatusBarItem(
+      vscode.StatusBarAlignment.Right,
+      100
+    );
+    
+    this.item.command = 'github-to-mcp.showQuickActions';
+    this.setIdle();
+    
+    // Register the quick actions command
+    context.subscriptions.push(
+      vscode.commands.registerCommand('github-to-mcp.showQuickActions', () => {
+        this.showQuickActions();
+      })
+    );
+
+    // Check if current workspace is a GitHub repo
+    this.updateVisibility();
+    
+    // Watch for workspace changes
+    context.subscriptions.push(
+      vscode.workspace.onDidChangeWorkspaceFolders(() => {
+        this.updateVisibility();
+      })
+    );
+  }
+
+  /**
+   * Update visibility based on workspace
+   */
+  private async updateVisibility(): Promise<void> {
+    const isGitHubRepo = await isCurrentWorkspaceGitHubRepo();
+    const config = vscode.workspace.getConfiguration('github-to-mcp');
+    const alwaysShow = config.get<boolean>('alwaysShowStatusBar', false);
+    
+    if (isGitHubRepo || alwaysShow) {
+      this.item.show();
+    } else {
+      this.item.hide();
+    }
+  }
+
+  /**
+   * Show quick actions menu
+   */
+  private async showQuickActions(): Promise<void> {
+    const items: vscode.QuickPickItem[] = [
+      {
+        label: '$(github) Convert from URL',
+        description: 'Enter a GitHub repository URL',
+        detail: 'Convert any public GitHub repository to MCP server'
+      },
+      {
+        label: '$(folder) Convert Current Repo',
+        description: 'Convert the open workspace',
+        detail: 'Convert the currently open GitHub repository'
+      },
+      {
+        label: '$(list-flat) Browse Registry',
+        description: 'Browse popular MCP servers',
+        detail: 'Choose from a curated list of repositories'
+      },
+      {
+        label: '$(gear) Configure Claude Desktop',
+        description: 'Auto-configure your MCP servers',
+        detail: 'Add converted servers to Claude Desktop config'
+      },
+      {
+        label: '',
+        kind: vscode.QuickPickItemKind.Separator
+      },
+      {
+        label: '$(history) View History',
+        description: 'See conversion history',
+        detail: 'View all previously converted repositories'
+      },
+      {
+        label: '$(output) Show Logs',
+        description: 'Open output channel',
+        detail: 'View extension logs and debug information'
+      }
+    ];
+
+    const selected = await vscode.window.showQuickPick(items, {
+      placeHolder: 'Select an action',
+      title: 'GitHub to MCP'
+    });
+
+    if (!selected) {
+      return;
+    }
+
+    switch (selected.label) {
+      case '$(github) Convert from URL':
+        vscode.commands.executeCommand('github-to-mcp.convertFromUrl');
+        break;
+      case '$(folder) Convert Current Repo':
+        vscode.commands.executeCommand('github-to-mcp.convertCurrentRepo');
+        break;
+      case '$(list-flat) Browse Registry':
+        vscode.commands.executeCommand('github-to-mcp.browseRegistry');
+        break;
+      case '$(gear) Configure Claude Desktop':
+        vscode.commands.executeCommand('github-to-mcp.configureClaudeDesktop');
+        break;
+      case '$(history) View History':
+        vscode.commands.executeCommand('github-to-mcp.history.focus');
+        break;
+      case '$(output) Show Logs':
+        vscode.commands.executeCommand('github-to-mcp.showOutput');
+        break;
+    }
+  }
+
+  /**
+   * Set status to idle
+   */
+  setIdle(): void {
+    this.stopProgress();
+    this.state = 'idle';
+    this.item.text = '$(github) MCP';
+    this.item.tooltip = 'GitHub to MCP: Click for actions';
+    this.item.backgroundColor = undefined;
+  }
+
+  /**
+   * Set status to loading with optional message
+   */
+  setLoading(message?: string): void {
+    this.state = 'loading';
+    this.item.tooltip = message || 'Converting repository...';
+    this.item.backgroundColor = new vscode.ThemeColor('statusBarItem.warningBackground');
+    this.startProgress();
+  }
+
+  /**
+   * Set status to success
+   */
+  setSuccess(message?: string): void {
+    this.stopProgress();
+    this.state = 'success';
+    this.item.text = '$(check) MCP';
+    this.item.tooltip = message || 'Conversion successful!';
+    this.item.backgroundColor = new vscode.ThemeColor('statusBarItem.prominentBackground');
+    
+    // Reset to idle after 3 seconds
+    setTimeout(() => {
+      if (this.state === 'success') {
+        this.setIdle();
+      }
+    }, 3000);
+  }
+
+  /**
+   * Set status to error
+   */
+  setError(message?: string): void {
+    this.stopProgress();
+    this.state = 'error';
+    this.item.text = '$(error) MCP';
+    this.item.tooltip = message || 'Conversion failed';
+    this.item.backgroundColor = new vscode.ThemeColor('statusBarItem.errorBackground');
+    
+    // Reset to idle after 5 seconds
+    setTimeout(() => {
+      if (this.state === 'error') {
+        this.setIdle();
+      }
+    }, 5000);
+  }
+
+  /**
+   * Start progress animation
+   */
+  private startProgress(): void {
+    this.stopProgress();
+    this.progressDots = 0;
+    
+    this.progressInterval = setInterval(() => {
+      this.progressDots = (this.progressDots + 1) % 4;
+      const dots = '.'.repeat(this.progressDots);
+      this.item.text = `$(sync~spin) MCP${dots}`;
+    }, 300);
+  }
+
+  /**
+   * Stop progress animation
+   */
+  private stopProgress(): void {
+    if (this.progressInterval) {
+      clearInterval(this.progressInterval);
+      this.progressInterval = null;
+    }
+  }
+
+  /**
+   * Show the status bar item
+   */
+  show(): void {
+    this.item.show();
+  }
+
+  /**
+   * Hide the status bar item
+   */
+  hide(): void {
+    this.item.hide();
+  }
+
+  /**
+   * Get current state
+   */
+  getState(): StatusBarState {
+    return this.state;
+  }
+
+  /**
+   * Dispose the status bar item
+   */
+  dispose(): void {
+    this.stopProgress();
+    this.item.dispose();
+  }
+}
+
+/**
+ * Create and initialize the status bar item
+ */
+export function createStatusBarItem(context: vscode.ExtensionContext): StatusBarItem {
+  return new StatusBarItem(context);
+}