@mofaggolhoshen/dev-assist-mcp 1.0.4

package/.vscode/mcp.json

@@ -0,0 +1,10 @@
+{
+  "servers": {
+    "dev-assist": {
+      "type": "stdio",
+      "command": "node",
+      "args": ["dist/index.js"],
+      "cwd": "${workspaceFolder}"
+    }
+  }
+}

package/README.md

@@ -0,0 +1,100 @@
+# DevAssist MCP Server
+
+stdio-based MCP server in TypeScript that exposes project file access, reusable snippets, and lightweight project analysis tools for AI clients.
+
+## Quick Start
+
+1. Install dependencies:
+
+```bash
+npm install
+```
+
+1. Build the server:
+
+```bash
+npm run build
+```
+
+1. Run locally (compiled):
+
+```bash
+npm start
+```
+
+1. Or run in development mode:
+
+```bash
+npm run dev
+```
+
+## VS Code MCP Configuration
+
+You can run the MCP server in VS Code either from this repository or from the published npm package.
+
+Local workspace setup:
+
+```json
+{
+  "servers": {
+    "dev-assist": {
+      "type": "stdio",
+      "command": "node",
+      "args": ["dist/index.js"],
+      "cwd": "${workspaceFolder}"
+    }
+  }
+}
+```
+
+Build once with `npm run build`, then VS Code can launch the server through stdio.
+
+Published npm package setup:
+
+```json
+{
+  "servers": {
+    "dev-assist": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@mofaggolhoshen/dev-assist-mcp-server"]
+    }
+  }
+}
+```
+
+This package-based setup is useful when you do not want to build the server from source inside each workspace.
+
+## Tool Catalog
+
+| Tool | Description | Input |
+| --- | --- | --- |
+| `ping` | Returns pong to verify the server is reachable | `{}` |
+| `list_files` | Lists files recursively under a directory | `{ path?: string }` |
+| `read_file` | Reads a text file from the workspace | `{ path: string }` |
+| `search_code` | Keyword search across text-like files | `{ keyword: string, path?: string }` |
+| `get_snippet` | Returns a named snippet from `snippets/` | `{ name: string }` |
+| `analyze_project` | Detects language/framework/architecture hints | `{ path?: string }` |
+
+## Adding Custom Tools
+
+1. Create a new tool module under `src/tools/...` implementing the `Tool` interface from `src/tools/types.ts`.
+2. Define `name`, `description`, `inputSchema` (Zod), and `execute`.
+3. Register the tool in `src/index.ts` using `registry.register(yourTool)`.
+4. Rebuild with `npm run build`.
+
+## Snippet Authoring
+
+Add JSON files under `snippets/` using this schema:
+
+```json
+{
+  "name": "snippet-name",
+  "title": "Human Friendly Title",
+  "language": "csharp",
+  "description": "What this snippet does",
+  "code": "...source code..."
+}
+```
+
+The `name` must match `[A-Za-z0-9-]+` because it maps to `snippets/{name}.json`.

package/dist/cli.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+const args = process.argv.slice(2);
+async function getPackageVersion() {
+    try {
+        const packagePath = new URL("../package.json", import.meta.url);
+        const raw = await fs.readFile(packagePath, "utf-8");
+        const pkg = JSON.parse(raw);
+        return pkg.version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+if (args.includes("--help") || args.includes("-h")) {
+    console.log(`dev-assist-mcp-server
+
+Usage:
+  npx -y @mofaggolhoshen/dev-assist-mcp-server
+
+Options:
+  -h, --help    Show this help message
+  -v, --version Show package version
+
+Description:
+  Starts the DevAssist MCP server over stdio for MCP clients.
+
+VS Code MCP setup:
+{
+  "servers": {
+    "dev-assist": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@mofaggolhoshen/dev-assist-mcp-server"]
+    }
+  }
+}`);
+    process.exit(0);
+}
+if (args.includes("--version") || args.includes("-v")) {
+    console.log(await getPackageVersion());
+    process.exit(0);
+}
+await import("./index.js");

package/dist/index.js

@@ -0,0 +1,24 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ToolRegistry } from "./tools/registry.js";
+import { listFilesTool } from "./tools/fs/listFiles.js";
+import { readFileTool } from "./tools/fs/readFile.js";
+import { searchCodeTool } from "./tools/fs/searchCode.js";
+import { getSnippetTool } from "./tools/knowledge/getSnippet.js";
+import { analyzeProjectTool } from "./tools/intelligence/analyzeProject.js";
+const server = new McpServer({ name: "dev-assist-mcp", version: "1.0.0" }, { capabilities: { tools: {} } });
+const registry = new ToolRegistry();
+//registry.register(pingTool);
+registry.register(listFilesTool);
+registry.register(readFileTool);
+registry.register(searchCodeTool);
+registry.register(getSnippetTool);
+registry.register(analyzeProjectTool);
+for (const tool of registry.list()) {
+    server.registerTool(tool.name, {
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+    }, async (args) => tool.execute(args));
+}
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/tools/fs/index.js

@@ -0,0 +1,3 @@
+export * from "./listFiles.js";
+export * from "./readFile.js";
+export * from "./searchCode.js";

package/dist/tools/fs/listFiles.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { glob } from "glob";
+import { resolveSafePath } from "./safePath.js";
+export const listFilesTool = {
+    name: "list_files",
+    description: "Lists files in a directory tree (relative to project root)",
+    inputSchema: z.object({
+        path: z
+            .string()
+            .optional()
+            .describe("Subdirectory to list (default: project root)"),
+    }),
+    async execute(input) {
+        const relPath = input.path || ".";
+        const dir = resolveSafePath(relPath);
+        const files = glob.sync("**/*", {
+            cwd: dir,
+            ignore: ["node_modules/**", "dist/**", ".git/**"],
+            nodir: true,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: files.join("\n"),
+                },
+            ],
+        };
+    },
+};

package/dist/tools/fs/readFile.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import fs from "fs/promises";
+import { resolveSafePath } from "./safePath.js";
+export const readFileTool = {
+    name: "read_file",
+    description: "Reads the content of a text file (relative to project root)",
+    inputSchema: z.object({
+        path: z.string().describe("Relative path to the file to read"),
+    }),
+    async execute(input) {
+        try {
+            const filePath = resolveSafePath(input.path);
+            const content = await fs.readFile(filePath, "utf-8");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: content,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error reading file: ${err.message}`,
+                    },
+                ],
+            };
+        }
+    },
+};

package/dist/tools/fs/safePath.js

@@ -0,0 +1,10 @@
+import path from "path";
+const PROJECT_ROOT = process.cwd();
+export function resolveSafePath(relativePath) {
+    const resolved = path.resolve(PROJECT_ROOT, relativePath);
+    const relative = path.relative(PROJECT_ROOT, resolved);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error("Access denied: path is outside the project root");
+    }
+    return resolved;
+}

package/dist/tools/fs/searchCode.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { glob } from "glob";
+import fs from "fs/promises";
+import path from "path";
+import { resolveSafePath } from "./safePath.js";
+function isTextFile(filename) {
+    // Simple extension check; can be improved
+    return /\.(ts|js|json|md|txt|c?jsx?|tsx?)$/i.test(filename);
+}
+export const searchCodeTool = {
+    name: "search_code",
+    description: "Searches for a keyword in text files (relative to project root)",
+    inputSchema: z.object({
+        keyword: z.string().describe("Text to search for in file contents"),
+        path: z
+            .string()
+            .optional()
+            .describe("Subdirectory to scope the search (default: project root)"),
+    }),
+    async execute(input) {
+        const relPath = input.path || ".";
+        const dir = resolveSafePath(relPath);
+        const files = glob.sync("**/*", {
+            cwd: dir,
+            ignore: ["node_modules/**", "dist/**", ".git/**"],
+            nodir: true,
+        });
+        const matches = [];
+        for (const file of files) {
+            if (!isTextFile(file))
+                continue;
+            try {
+                const content = await fs.readFile(path.join(dir, file), "utf-8");
+                content.split(/\r?\n/).forEach((line, idx) => {
+                    if (line.toLowerCase().includes(input.keyword.toLowerCase())) {
+                        matches.push(`${file}:${idx + 1}: ${line}`);
+                    }
+                });
+                if (matches.length >= 50)
+                    break;
+            }
+            catch { }
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: matches.slice(0, 50).join("\n"),
+                },
+            ],
+        };
+    },
+};

package/dist/tools/intelligence/analyzeProject.js

@@ -0,0 +1,127 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { glob } from "glob";
+import { z } from "zod";
+import { resolveSafePath } from "../fs/safePath.js";
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function detectFromPackageJson(projectDir, result) {
+    const packageJsonPath = path.join(projectDir, "package.json");
+    if (!(await fileExists(packageJsonPath))) {
+        return;
+    }
+    if (!result.language.includes("JavaScript")) {
+        result.language.push("JavaScript");
+    }
+    if (!result.framework.includes("Node.js")) {
+        result.framework.push("Node.js");
+    }
+    try {
+        const raw = await fs.readFile(packageJsonPath, "utf-8");
+        const pkg = JSON.parse(raw);
+        const deps = {
+            ...(pkg.dependencies ?? {}),
+            ...(pkg.devDependencies ?? {}),
+        };
+        if (deps.typescript && !result.language.includes("TypeScript")) {
+            result.language.push("TypeScript");
+        }
+        if (deps["@modelcontextprotocol/sdk"] &&
+            !result.framework.includes("MCP SDK")) {
+            result.framework.push("MCP SDK");
+        }
+    }
+    catch {
+        // Skip malformed package.json and continue returning partial analysis.
+    }
+}
+export const analyzeProjectTool = {
+    name: "analyze_project",
+    description: "Analyzes project structure to detect language, framework, and architecture hints",
+    inputSchema: z.object({
+        path: z
+            .string()
+            .optional()
+            .describe("Project root to analyze (default: server working directory)"),
+    }),
+    async execute(input) {
+        const relPath = input.path || ".";
+        const projectDir = resolveSafePath(relPath);
+        const result = {
+            language: [],
+            framework: [],
+            architecture: [],
+            containerized: false,
+            multi_container: false,
+            files_count: 0,
+        };
+        const rootEntries = await fs.readdir(projectDir, { withFileTypes: true });
+        const rootNames = new Set(rootEntries.map((entry) => entry.name));
+        const csprojFiles = glob.sync("**/*.csproj", {
+            cwd: projectDir,
+            ignore: ["node_modules/**", "dist/**", ".git/**"],
+            nodir: true,
+        });
+        const slnFiles = glob.sync("**/*.sln", {
+            cwd: projectDir,
+            ignore: ["node_modules/**", "dist/**", ".git/**"],
+            nodir: true,
+        });
+        const allFiles = glob.sync("**/*", {
+            cwd: projectDir,
+            ignore: ["node_modules/**", "dist/**", ".git/**"],
+            nodir: true,
+        });
+        result.files_count = allFiles.length;
+        if (csprojFiles.length > 0 || slnFiles.length > 0) {
+            result.language.push("C#/.NET");
+        }
+        if (rootNames.has("go.mod")) {
+            result.language.push("Go");
+        }
+        if (rootNames.has("requirements.txt") || rootNames.has("pyproject.toml")) {
+            result.language.push("Python");
+        }
+        await detectFromPackageJson(projectDir, result);
+        if (rootNames.has("angular.json")) {
+            result.framework.push("Angular");
+        }
+        const hasNextConfig = glob.sync("next.config.*", {
+            cwd: projectDir,
+            nodir: true,
+        }).length > 0;
+        if (hasNextConfig) {
+            result.framework.push("Next.js");
+        }
+        const hasViteConfig = glob.sync("vite.config.*", {
+            cwd: projectDir,
+            nodir: true,
+        }).length > 0;
+        if (hasViteConfig) {
+            result.framework.push("Vite");
+        }
+        if (rootNames.has("Program.cs") && csprojFiles.length > 0) {
+            result.framework.push("ASP.NET Core");
+        }
+        result.containerized = rootNames.has("Dockerfile");
+        result.multi_container =
+            rootNames.has("docker-compose.yml") ||
+                rootNames.has("docker-compose.yaml");
+        if (rootNames.has("src") &&
+            (rootNames.has("tests") || rootNames.has("test"))) {
+            result.architecture.push("standard src/test layout");
+        }
+        if (slnFiles.length > 0 && csprojFiles.length > 1) {
+            result.architecture.push("multi-project solution");
+        }
+        const text = JSON.stringify(result, null, 2);
+        return { content: [{ type: "text", text }] };
+    },
+};

package/dist/tools/intelligence/index.js

@@ -0,0 +1 @@
+export * from "./analyzeProject.js";

package/dist/tools/knowledge/getSnippet.js

@@ -0,0 +1,64 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { resolveSafePath } from "../fs/safePath.js";
+const snippetFileSchema = z.object({
+    name: z.string(),
+    title: z.string(),
+    language: z.string(),
+    description: z.string(),
+    code: z.string(),
+});
+async function listAvailableSnippetNames(snippetsDir) {
+    try {
+        const entries = await fs.readdir(snippetsDir, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map((entry) => entry.name.replace(/\.json$/i, ""))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+export const getSnippetTool = {
+    name: "get_snippet",
+    description: "Returns a reusable code snippet by name from the local snippets directory",
+    inputSchema: z.object({
+        name: z
+            .string()
+            .regex(/^[A-Za-z0-9-]+$/, "Snippet name can only contain letters, numbers, and hyphens")
+            .describe("Snippet name, e.g. 'polly-retry', 'jwt-setup'"),
+    }),
+    async execute(input) {
+        const snippetsDir = resolveSafePath("snippets");
+        const filePath = path.join(snippetsDir, `${input.name}.json`);
+        try {
+            const raw = await fs.readFile(filePath, "utf-8");
+            const snippet = snippetFileSchema.parse(JSON.parse(raw));
+            const text = [
+                `# ${snippet.title}`,
+                "",
+                snippet.description,
+                "",
+                `Language: ${snippet.language}`,
+                "",
+                `\`\`\`${snippet.language}`,
+                snippet.code,
+                "\`\`\`",
+            ].join("\n");
+            return { content: [{ type: "text", text }] };
+        }
+        catch (err) {
+            const available = await listAvailableSnippetNames(snippetsDir);
+            const availableText = available.length
+                ? available.join(", ")
+                : "No snippets found. Add JSON files under snippets/.";
+            const notFound = err?.code === "ENOENT";
+            const text = notFound
+                ? `Snippet '${input.name}' was not found. Available snippets: ${availableText}`
+                : `Could not load snippet '${input.name}': ${err.message}. Available snippets: ${availableText}`;
+            return { content: [{ type: "text", text }] };
+        }
+    },
+};

package/dist/tools/knowledge/index.js

@@ -0,0 +1 @@
+export * from "./getSnippet.js";

package/dist/tools/ping.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export const pingTool = {
+    name: "ping",
+    description: "Returns pong — used to verify the server is working",
+    inputSchema: z.object({}),
+    execute: async () => ({ content: [{ type: "text", text: "pong" }] }),
+};

package/dist/tools/registry.js

@@ -0,0 +1,15 @@
+export class ToolRegistry {
+    tools = new Map();
+    register(tool) {
+        if (this.tools.has(tool.name)) {
+            throw new Error(`Tool with name '${tool.name}' is already registered.`);
+        }
+        this.tools.set(tool.name, tool);
+    }
+    list() {
+        return Array.from(this.tools.values());
+    }
+    get(name) {
+        return this.tools.get(name);
+    }
+}

package/dist/tools/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@mofaggolhoshen/dev-assist-mcp",
+  "version": "1.0.4",
+  "description": "",
+  "main": "dist/index.js",
+  "bin": {
+    "dev-assist-mcp": "dist/cli.js"
+  },
+  "directories": {
+    "doc": "docs"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "test": "jest"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MofaggolHoshen/dev-assist-mcp-server.git"
+  },
+  "bugs": {
+    "url": "https://github.com/MofaggolHoshen/dev-assist-mcp-server/issues"
+  },
+  "homepage": "https://github.com/MofaggolHoshen/dev-assist-mcp-server#readme",
+  "type": "module",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "glob": "^13.0.6",
+    "zod": "^4.3.6",
+    "zod-to-json-schema": "^3.25.2"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.6.0",
+    "jest": "^30.3.0",
+    "ts-jest": "^29.4.9",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.3"
+  }
+}

package/snippets/efcore-repository.json

@@ -0,0 +1,7 @@
+{
+  "name": "efcore-repository",
+  "title": "EF Core Repository Pattern",
+  "language": "csharp",
+  "description": "Simple EF Core repository with asynchronous read/write operations.",
+  "code": "public sealed class ProductRepository(AppDbContext db)\n{\n    public Task<Product?> GetByIdAsync(Guid id, CancellationToken ct = default) =>\n        db.Products.FirstOrDefaultAsync(p => p.Id == id, ct);\n\n    public async Task AddAsync(Product entity, CancellationToken ct = default)\n    {\n        await db.Products.AddAsync(entity, ct);\n        await db.SaveChangesAsync(ct);\n    }\n}"
+}

package/snippets/jwt-setup.json

@@ -0,0 +1,7 @@
+{
+  "name": "jwt-setup",
+  "title": "JWT Authentication Setup (ASP.NET Core)",
+  "language": "csharp",
+  "description": "Configures JWT bearer authentication with token validation parameters.",
+  "code": "builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)\n    .AddJwtBearer(options =>\n    {\n        options.TokenValidationParameters = new TokenValidationParameters\n        {\n            ValidateIssuer = true,\n            ValidateAudience = true,\n            ValidateIssuerSigningKey = true,\n            ValidIssuer = config[\"Jwt:Issuer\"],\n            ValidAudience = config[\"Jwt:Audience\"],\n            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(config[\"Jwt:Key\"]!))\n        };\n    });"
+}

package/snippets/polly-retry.json

@@ -0,0 +1,7 @@
+{
+  "name": "polly-retry",
+  "title": "Polly Retry Policy (.NET)",
+  "language": "csharp",
+  "description": "Configures an HTTP retry policy with exponential backoff using Polly.",
+  "code": "builder.Services.AddHttpClient(\"MyClient\")\n  .AddTransientHttpErrorPolicy(p =>\n    p.WaitAndRetryAsync(3, attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt))));"
+}