dotnet-ai-mcp-server 1.0.2 → 1.0.3

package/README.md

@@ -1,99 +1,50 @@
-# DotNet AI MCP Server
+# dotnet-ai-mcp-server
 
-The essential Model Context Protocol server for .NET developers building AI applications.
+MCP Server for .NET AI development - provides real code samples from Semantic Kernel, OpenAI .NET, MCP C# SDK, and more.
 
-## Quick Start
+## Installation
 
-### Using npx (Recommended)
+```bash
+npm install -g dotnet-ai-mcp-server
+```
 
-Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
+Or use with npx (no installation needed):
 
-```json
-{
-  "mcpServers": {
-    "dotnet-ai": {
-      "command": "npx",
-      "args": ["-y", "dotnet-ai-mcp-server"]
-    }
-  }
-}
+```bash
+npx dotnet-ai-mcp-server
 ```
 
-### Using VS Code / GitHub Copilot
+## Usage with Claude Desktop
 
-Add to your VS Code MCP settings:
+Add to your `claude_desktop_config.json`:
 
 ```json
 {
-  "mcp": {
-    "servers": {
-      "dotnet-ai": {
-        "command": "npx",
-        "args": ["-y", "dotnet-ai-mcp-server"]
-      }
+  "mcpServers": {
+    "dotnet-ai": {
+      "command": "npx",
+      "args": ["-y", "dotnet-ai-mcp-server"]
     }
   }
 }
 ```
 
-## Prerequisites
-
-- [.NET 9.0 SDK](https://dotnet.microsoft.com/download) - Required for the underlying dotnet tool
-- Node.js 16+ - For npx
-
-## What This Does
-
-This MCP server provides real, up-to-date code samples from the .NET AI ecosystem:
+### Config file locations:
+- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
 
-- **Semantic Kernel** - AI orchestration framework
-- **OpenAI .NET SDK** - Official OpenAI client
-- **MCP C# SDK** - Model Context Protocol for .NET
-- **Microsoft.Extensions.AI** - AI abstractions
-- **Anthropic SDK** - Claude SDK for .NET
-- **Google GenAI** - Gemini SDK for .NET
-- **Vector DBs** - Pinecone, Qdrant, Weaviate, Redis
+## Features
 
-## Why Use This?
+- **Real code samples** from official Microsoft repositories
+- **GitHub integration** - fetches live code from Semantic Kernel, OpenAI .NET, MCP C# SDK, and more
+- **Microsoft Learn docs** - searches official documentation
+- **No .NET SDK required** - self-contained executable
 
-LLMs hallucinate .NET AI APIs. Training data can't keep up with rapidly evolving libraries like Semantic Kernel. This server fetches real code from live GitHub repositories.
+## Supported Platforms
 
-## Available Tools
-
-| Tool | Description |
-|------|-------------|
-| `Start_DotNet_Reasoning` | Entry point - lists tracked repositories |
-| `GitHubGetFolders` | Shows folder structure |
-| `GitHubListFiles` | Lists files in folders |
-| `GitHubFetchFiles` | Fetches actual code |
-| `MicrosoftDocsSearch` | Searches Microsoft Learn |
-| `MicrosoftDocsFetch` | Fetches documentation |
-| `MicrosoftCodeSampleSearch` | Finds code samples |
-
-## How It Works
-
-1. The npm package installs the .NET global tool (`dotnet tool install -g DotNetAIMcpServer`)
-2. When invoked via npx, it runs the dotnet tool which communicates via stdio
-3. The tool fetches live code from GitHub and Microsoft Learn
-
-## Manual Installation
-
-If you prefer to install the dotnet tool directly:
-
-```bash
-dotnet tool install -g DotNetAIMcpServer
-```
-
-Then configure your MCP client to use:
-
-```json
-{
-  "mcpServers": {
-    "dotnet-ai": {
-      "command": "dotnet-ai-mcp"
-    }
-  }
-}
-```
+- macOS (Intel & Apple Silicon)
+- Linux (x64 & ARM64)
+- Windows (x64)
 
 ## License
 

package/bin/cli.js

@@ -1,93 +1,31 @@
 #!/usr/bin/env node
 
 const { spawn } = require('child_process');
-const { existsSync } = require('fs');
-const { join } = require('path');
+const path = require('path');
 const os = require('os');
+const fs = require('fs');
 
-const TOOL_NAME = 'dotnet-ai-mcp';
-const NUGET_PACKAGE = 'DotNetAIMcpServer';
+const isWindows = os.platform() === 'win32';
+const binaryName = isWindows ? 'dotnet-ai-mcp-server.exe' : 'dotnet-ai-mcp-server';
+const binaryPath = path.join(__dirname, binaryName);
 
-async function checkDotnetInstalled() {
-    return new Promise((resolve) => {
-        const proc = spawn('dotnet', ['--version'], { stdio: 'pipe' });
-        proc.on('close', (code) => resolve(code === 0));
-        proc.on('error', () => resolve(false));
-    });
+if (!fs.existsSync(binaryPath)) {
+    console.error('Binary not found. Please reinstall the package:');
+    console.error('  npm uninstall -g dotnet-ai-mcp-server');
+    console.error('  npm install -g dotnet-ai-mcp-server');
+    process.exit(1);
 }
 
-async function checkToolInstalled() {
-    return new Promise((resolve) => {
-        const proc = spawn('dotnet', ['tool', 'list', '-g'], { stdio: 'pipe' });
-        let output = '';
-        proc.stdout.on('data', (data) => { output += data.toString(); });
-        proc.on('close', () => {
-            resolve(output.toLowerCase().includes(NUGET_PACKAGE.toLowerCase()));
-        });
-        proc.on('error', () => resolve(false));
-    });
-}
-
-async function installTool() {
-    console.error(`Installing ${NUGET_PACKAGE}...`);
-    return new Promise((resolve, reject) => {
-        const proc = spawn('dotnet', ['tool', 'install', '-g', NUGET_PACKAGE], {
-            stdio: 'inherit'
-        });
-        proc.on('close', (code) => {
-            if (code === 0) resolve();
-            else reject(new Error(`Failed to install ${NUGET_PACKAGE}`));
-        });
-        proc.on('error', reject);
-    });
-}
-
-async function runTool() {
-    const isWindows = os.platform() === 'win32';
-    const toolPath = isWindows
-        ? join(os.homedir(), '.dotnet', 'tools', `${TOOL_NAME}.exe`)
-        : join(os.homedir(), '.dotnet', 'tools', TOOL_NAME);
-
-    // Always use full path for reliability
-    const proc = spawn(toolPath, [], {
-        stdio: 'inherit',
-        shell: false
-    });
-
-    proc.on('error', (err) => {
-        console.error(`Error running ${TOOL_NAME}: ${err.message}`);
-        console.error(`Tried path: ${toolPath}`);
-        console.error('Make sure the dotnet tool is installed: dotnet tool install -g DotNetAIMcpServer');
-        process.exit(1);
-    });
+const proc = spawn(binaryPath, process.argv.slice(2), {
+    stdio: 'inherit',
+    shell: false
+});
 
-    proc.on('close', (code) => {
-        process.exit(code || 0);
-    });
-}
-
-async function main() {
-    try {
-        // Check if .NET is installed
-        const dotnetInstalled = await checkDotnetInstalled();
-        if (!dotnetInstalled) {
-            console.error('ERROR: .NET SDK is not installed.');
-            console.error('Please install .NET 9.0 SDK from: https://dotnet.microsoft.com/download');
-            process.exit(1);
-        }
-
-        // Check if the tool is installed
-        const toolInstalled = await checkToolInstalled();
-        if (!toolInstalled) {
-            await installTool();
-        }
-
-        // Run the tool
-        await runTool();
-    } catch (error) {
-        console.error(`Error: ${error.message}`);
-        process.exit(1);
-    }
-}
+proc.on('error', (err) => {
+    console.error(`Failed to start server: ${err.message}`);
+    process.exit(1);
+});
 
-main();
+proc.on('close', (code) => {
+    process.exit(code || 0);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotnet-ai-mcp-server",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "MCP Server for .NET AI development - provides real code samples from Semantic Kernel, OpenAI .NET, MCP C# SDK, and more",
   "bin": {
     "dotnet-ai-mcp-server": "bin/cli.js"

package/scripts/postinstall.js

@@ -1,85 +1,104 @@
 #!/usr/bin/env node
 
-const { spawn } = require('child_process');
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
 
-const NUGET_PACKAGE = 'DotNetAIMcpServer';
+const REPO = 'ArbelH/dotnet-ai-mcp-server';
+const VERSION = require('../package.json').version;
 
-async function checkDotnetInstalled() {
-    return new Promise((resolve) => {
-        const proc = spawn('dotnet', ['--version'], { stdio: 'pipe' });
-        proc.on('close', (code) => resolve(code === 0));
-        proc.on('error', () => resolve(false));
-    });
-}
+function getPlatformInfo() {
+    const platform = os.platform();
+    const arch = os.arch();
 
-async function checkToolInstalled() {
-    return new Promise((resolve) => {
-        const proc = spawn('dotnet', ['tool', 'list', '-g'], { stdio: 'pipe' });
-        let output = '';
-        proc.stdout.on('data', (data) => { output += data.toString(); });
-        proc.on('close', () => {
-            resolve(output.toLowerCase().includes(NUGET_PACKAGE.toLowerCase()));
-        });
-        proc.on('error', () => resolve(false));
-    });
+    const platformMap = {
+        'darwin-x64': 'dotnet-ai-mcp-server-darwin-x64',
+        'darwin-arm64': 'dotnet-ai-mcp-server-darwin-arm64',
+        'linux-x64': 'dotnet-ai-mcp-server-linux-x64',
+        'linux-arm64': 'dotnet-ai-mcp-server-linux-arm64',
+        'win32-x64': 'dotnet-ai-mcp-server-win-x64.exe',
+    };
+
+    const key = `${platform}-${arch}`;
+    const binaryName = platformMap[key];
+
+    if (!binaryName) {
+        console.error(`Unsupported platform: ${platform}-${arch}`);
+        console.error('Supported platforms: darwin-x64, darwin-arm64, linux-x64, linux-arm64, win32-x64');
+        process.exit(1);
+    }
+
+    return { binaryName, isWindows: platform === 'win32' };
 }
 
-async function installTool() {
-    console.log(`Installing ${NUGET_PACKAGE} dotnet tool...`);
+function downloadFile(url, dest) {
     return new Promise((resolve, reject) => {
-        const proc = spawn('dotnet', ['tool', 'install', '-g', NUGET_PACKAGE], {
-            stdio: 'inherit'
-        });
-        proc.on('close', (code) => {
-            if (code === 0) {
-                console.log(`${NUGET_PACKAGE} installed successfully!`);
-                resolve();
-            } else {
-                // Tool might already be installed, try update
-                const updateProc = spawn('dotnet', ['tool', 'update', '-g', NUGET_PACKAGE], {
-                    stdio: 'inherit'
+        const follow = (url, redirectCount = 0) => {
+            if (redirectCount > 5) {
+                reject(new Error('Too many redirects'));
+                return;
+            }
+
+            https.get(url, { headers: { 'User-Agent': 'dotnet-ai-mcp-server-npm' } }, (response) => {
+                if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+                    follow(response.headers.location, redirectCount + 1);
+                    return;
+                }
+
+                if (response.statusCode !== 200) {
+                    reject(new Error(`Failed to download: ${response.statusCode}`));
+                    return;
+                }
+
+                const file = fs.createWriteStream(dest);
+                response.pipe(file);
+                file.on('finish', () => {
+                    file.close();
+                    resolve();
                 });
-                updateProc.on('close', (updateCode) => {
-                    if (updateCode === 0) {
-                        console.log(`${NUGET_PACKAGE} updated successfully!`);
-                        resolve();
-                    } else {
-                        reject(new Error(`Failed to install/update ${NUGET_PACKAGE}`));
-                    }
+                file.on('error', (err) => {
+                    fs.unlink(dest, () => {});
+                    reject(err);
                 });
-                updateProc.on('error', reject);
-            }
-        });
-        proc.on('error', reject);
+            }).on('error', reject);
+        };
+
+        follow(url);
     });
 }
 
 async function main() {
+    const { binaryName, isWindows } = getPlatformInfo();
+    const binDir = path.join(__dirname, '..', 'bin');
+    const binaryPath = path.join(binDir, isWindows ? 'dotnet-ai-mcp-server.exe' : 'dotnet-ai-mcp-server');
+
+    // Skip if binary already exists
+    if (fs.existsSync(binaryPath)) {
+        console.log('Binary already exists, skipping download.');
+        return;
+    }
+
+    const downloadUrl = `https://github.com/${REPO}/releases/download/v${VERSION}/${binaryName}`;
+
+    console.log(`Downloading ${binaryName}...`);
+    console.log(`URL: ${downloadUrl}`);
+
     try {
-        // Check if .NET is installed
-        const dotnetInstalled = await checkDotnetInstalled();
-        if (!dotnetInstalled) {
-            console.log('\n========================================');
-            console.log('  .NET SDK Required');
-            console.log('========================================');
-            console.log('This package requires .NET 9.0 SDK.');
-            console.log('Please install from: https://dotnet.microsoft.com/download');
-            console.log('========================================\n');
-            return; // Don't fail, just warn
-        }
+        await downloadFile(downloadUrl, binaryPath);
 
-        // Check if already installed
-        const toolInstalled = await checkToolInstalled();
-        if (toolInstalled) {
-            console.log(`${NUGET_PACKAGE} is already installed.`);
-            return;
+        if (!isWindows) {
+            fs.chmodSync(binaryPath, 0o755);
         }
 
-        // Install the tool
-        await installTool();
+        console.log('Download complete!');
     } catch (error) {
-        console.error(`Warning: Could not install ${NUGET_PACKAGE}: ${error.message}`);
-        console.error('You can install it manually with: dotnet tool install -g DotNetAIMcpServer');
+        console.error(`Failed to download binary: ${error.message}`);
+        console.error('');
+        console.error('You may need to download it manually from:');
+        console.error(`https://github.com/${REPO}/releases`);
+        process.exit(1);
     }
 }