@devstroupe/devkit-mcp 1.0.0

package/README.md

@@ -0,0 +1,92 @@
+# @devstroupe/devkit-mcp
+
+[![npm version](https://img.shields.io/npm/v/@devstroupe/devkit-mcp?color=purple)](https://www.npmjs.com/package/@devstroupe/devkit-mcp)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](../../LICENSE)
+
+Servidor **Model Context Protocol (MCP)** do DT-DevKit. Expõe todas as automações da CLI como ferramentas nativas para agentes de IA (Cursor, VS Code, Claude Desktop, Gemini, Windsurf e outros).
+
+## Instalação
+
+```bash
+npm install -g @devstroupe/devkit-mcp
+```
+
+## Ferramentas MCP disponíveis
+
+| Ferramenta | Descrição |
+|---|---|
+| `ds_get_config` | Retorna o `devstroupe.config.ts` completo formatado |
+| `ds_list_entities` | Lista as entidades e propriedades configuradas |
+| `ds_init_ui` | Inicializa o Design System Spartan NG no projeto Angular |
+| `ds_generate_crud` | Gera CRUD completo (backend + frontend) para uma entidade |
+| `ds_check_architecture` | Auditoria de conformidade com as regras de governança |
+| `ds_set_spartan_style` | Troca o style visual do Spartan NG |
+| `ds_new_project` | Cria um novo projeto DevKit integrado |
+| `ds_generate_migration` | Gera migration TypeORM no backend |
+| `ds_run_harnesses` | Roda os testes e harnesses do framework |
+
+## Configuração nas IDEs
+
+### Cursor / VS Code
+```json
+{
+  "mcpServers": {
+    "devkit": { "command": "devstroupe-mcp" }
+  }
+}
+```
+
+### Claude Desktop
+Arquivo: `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) ou `%APPDATA%\Claude\claude_desktop_config.json` (Windows)
+```json
+{
+  "mcpServers": {
+    "devkit": { "command": "devstroupe-mcp" }
+  }
+}
+```
+
+### Gemini / Antigravity (Google IDE)
+```json
+{
+  "servers": {
+    "devkit": { "command": "devstroupe-mcp" }
+  }
+}
+```
+
+### Windsurf
+```json
+{
+  "mcpServers": {
+    "devkit": { "command": "devstroupe-mcp" }
+  }
+}
+```
+
+### Monorepo local (desenvolvimento do framework)
+```json
+{
+  "mcpServers": {
+    "devkit": {
+      "command": "node",
+      "args": ["/caminho/absoluto/para/packages/devkit-mcp/dist/index.js"]
+    }
+  }
+}
+```
+
+## Como o servidor resolve o CLI
+
+O `devkit-mcp` tenta resolver automaticamente o `@devstroupe/devkit-cli`:
+1. Primeiro via `require.resolve('@devstroupe/devkit-cli/dist/index.js')` — instalação npm
+2. Fallback: path relativo `../../devkit-cli/dist/index.js` — monorepo local
+
+## Harnesses para IAs
+
+O `ds_run_harnesses` roda `pnpm test` no monorepo do DevKit, executando:
+- Testes de regras do linter (`linter-rules.test.ts`)
+- Testes de templates de relacionamentos (`relationship-templates.test.ts`)
+- Testes de integração do MCP (`integration.test.ts`)
+
+Use após modificar templates ou regras para garantir que o framework está funcionando corretamente.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,353 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+const readline = __importStar(require("readline"));
+const child_process_1 = require("child_process");
+// Registrar ts-node para carregar a config TS
+try {
+    require('ts-node').register({
+        compilerOptions: { module: 'commonjs' }
+    });
+}
+catch (e) {
+    // Ignora se não houver ts-node
+}
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false
+});
+const SPARTAN_STYLES = ['nova', 'vega', 'lyra', 'maia', 'mira', 'luma'];
+/**
+ * Resolve o caminho do CLI do devstroupe.
+ * Quando instalado via npm: usa require.resolve('@devstroupe/devkit-cli/dist/index.js')
+ * Em desenvolvimento local (monorepo): usa path relativo
+ */
+function resolveCliPath() {
+    // Tenta resolver via npm (instalado como dependência)
+    try {
+        return require.resolve('@devstroupe/devkit-cli/dist/index.js');
+    }
+    catch {
+        // Fallback: desenvolvimento local no monorepo
+        return path.resolve(__dirname, '../../devkit-cli/dist/index.js');
+    }
+}
+function sendResponse(response) {
+    process.stdout.write(JSON.stringify(response) + '\n');
+}
+function sendError(id, code, message) {
+    sendResponse({ jsonrpc: '2.0', id, error: { code, message } });
+}
+function sendResult(id, result) {
+    sendResponse({ jsonrpc: '2.0', id, result });
+}
+rl.on('line', (line) => {
+    if (!line.trim())
+        return;
+    try {
+        const request = JSON.parse(line);
+        if (request.id === undefined)
+            return; // notificações
+        handleRequest(request);
+    }
+    catch (err) {
+        sendError(null, -32700, 'Parse error');
+    }
+});
+function handleRequest(request) {
+    const { id, method, params } = request;
+    switch (method) {
+        case 'initialize':
+            sendResult(id, {
+                protocolVersion: '2024-11-05',
+                capabilities: { tools: {} },
+                serverInfo: { name: 'devkit-mcp', version: '1.0.0' }
+            });
+            break;
+        case 'tools/list':
+            sendResult(id, {
+                tools: [
+                    {
+                        name: 'ds_list_entities',
+                        description: 'Lista todas as entidades e propriedades configuradas no devstroupe.config.ts do projeto.',
+                        inputSchema: { type: 'object', properties: {} }
+                    },
+                    {
+                        name: 'ds_get_config',
+                        description: 'Retorna o conteúdo completo e formatado do devstroupe.config.ts. Use antes de gerar CRUDs ou tomar decisões arquiteturais.',
+                        inputSchema: { type: 'object', properties: {} }
+                    },
+                    {
+                        name: 'ds_generate_crud',
+                        description: 'Gera backend NestJS + frontend Angular completos (controller, service, repository, module, list, form) para uma entidade configurada no devstroupe.config.ts.',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                entityName: {
+                                    type: 'string',
+                                    description: 'Nome da entidade conforme declarado no config (ex: cabin, booking, user)'
+                                }
+                            },
+                            required: ['entityName']
+                        }
+                    },
+                    {
+                        name: 'ds_check_architecture',
+                        description: 'Executa a auditoria estática de governança arquitetural (linter) e retorna o relatório detalhado de violações. Use após gerar código para garantir conformidade.',
+                        inputSchema: { type: 'object', properties: {} }
+                    },
+                    {
+                        name: 'ds_init_ui',
+                        description: 'Inicializa o Design System Angular com primitivos reais do Spartan Helm (libs/ui), injeta wrappers devkit-*, ThemeService, ProfileComponent e layout. Obrigatório antes de gerar CRUDs no frontend.',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                style: {
+                                    type: 'string',
+                                    enum: ['nova', 'vega', 'lyra', 'maia', 'mira', 'luma'],
+                                    description: 'Style visual do Spartan NG. Padrão: vega'
+                                }
+                            }
+                        }
+                    },
+                    {
+                        name: 'ds_set_spartan_style',
+                        description: 'Altera o style visual do Spartan NG e regenera todos os primitivos Helm em libs/ui. Atenção: não misture styles no mesmo app.',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                style: {
+                                    type: 'string',
+                                    enum: ['nova', 'vega', 'lyra', 'maia', 'mira', 'luma'],
+                                    description: 'Novo style Spartan'
+                                }
+                            },
+                            required: ['style']
+                        }
+                    },
+                    {
+                        name: 'ds_new_project',
+                        description: 'Cria um novo projeto integrado NestJS + Angular com o DevKit já configurado. Deve ser rodado na pasta onde o projeto será criado.',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                projectName: {
+                                    type: 'string',
+                                    description: 'Nome do projeto (ex: minha-app)'
+                                }
+                            },
+                            required: ['projectName']
+                        }
+                    },
+                    {
+                        name: 'ds_generate_migration',
+                        description: 'Gera uma migration TypeORM para o backend do projeto. Execute após criar ou modificar entidades para manter o schema do banco sincronizado.',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                backendPath: {
+                                    type: 'string',
+                                    description: 'Caminho para a pasta raiz do backend NestJS (padrão: ./backend)'
+                                }
+                            }
+                        }
+                    },
+                    {
+                        name: 'ds_run_harnesses',
+                        description: 'Executa os testes e harnesses do framework DevKit para validar que o código gerado e as regras de governança estão funcionando corretamente.',
+                        inputSchema: { type: 'object', properties: {} }
+                    }
+                ]
+            });
+            break;
+        case 'tools/call':
+            if (!params || !params.name) {
+                sendError(id, -32602, 'Invalid params: name is required');
+                break;
+            }
+            handleToolCall(id, params.name, params.arguments || {});
+            break;
+        default:
+            sendError(id, -32601, 'Method not found');
+            break;
+    }
+}
+function handleToolCall(id, toolName, args) {
+    const configPath = path.join(process.cwd(), 'devstroupe.config.ts');
+    const cliPath = resolveCliPath();
+    // ── ds_list_entities ──────────────────────────────────────────────────────
+    if (toolName === 'ds_list_entities') {
+        if (!fs.existsSync(configPath)) {
+            return sendResult(id, {
+                content: [{ type: 'text', text: 'devstroupe.config.ts não encontrado. Rode "devstroupe init" primeiro.' }],
+                isError: true
+            });
+        }
+        try {
+            delete require.cache[require.resolve(configPath)];
+            const importedConfig = require(configPath);
+            const config = importedConfig.default || importedConfig;
+            sendResult(id, {
+                content: [{ type: 'text', text: JSON.stringify(config.entities || [], null, 2) }]
+            });
+        }
+        catch (err) {
+            sendResult(id, {
+                content: [{ type: 'text', text: `Erro ao carregar config: ${err.message}` }],
+                isError: true
+            });
+        }
+        // ── ds_get_config ─────────────────────────────────────────────────────────
+    }
+    else if (toolName === 'ds_get_config') {
+        if (!fs.existsSync(configPath)) {
+            return sendResult(id, {
+                content: [{ type: 'text', text: 'devstroupe.config.ts não encontrado. Rode "devstroupe init" primeiro.' }],
+                isError: true
+            });
+        }
+        try {
+            delete require.cache[require.resolve(configPath)];
+            const importedConfig = require(configPath);
+            const config = importedConfig.default || importedConfig;
+            sendResult(id, {
+                content: [{ type: 'text', text: JSON.stringify(config, null, 2) }]
+            });
+        }
+        catch (err) {
+            sendResult(id, {
+                content: [{ type: 'text', text: `Erro ao carregar config: ${err.message}` }],
+                isError: true
+            });
+        }
+        // ── ds_generate_crud ──────────────────────────────────────────────────────
+    }
+    else if (toolName === 'ds_generate_crud') {
+        const { entityName } = args;
+        if (!entityName)
+            return sendError(id, -32602, 'entityName é obrigatório');
+        (0, child_process_1.exec)(`node "${cliPath}" generate crud "${entityName}"`, (err, stdout, stderr) => {
+            sendResult(id, {
+                content: [{ type: 'text', text: err ? `Falha: ${stderr || err.message}` : stdout || `CRUD de "${entityName}" gerado com sucesso!` }],
+                isError: !!err
+            });
+        });
+        // ── ds_check_architecture ─────────────────────────────────────────────────
+    }
+    else if (toolName === 'ds_check_architecture') {
+        (0, child_process_1.exec)(`node "${cliPath}" lint:rules`, (err, stdout, stderr) => {
+            const hasViolations = !!err && !stdout.includes('Varredura finalizada');
+            sendResult(id, {
+                content: [{ type: 'text', text: stdout || stderr || 'Auditoria concluída sem saída.' }],
+                isError: hasViolations
+            });
+        });
+        // ── ds_init_ui ────────────────────────────────────────────────────────────
+    }
+    else if (toolName === 'ds_init_ui') {
+        if (args.style && !SPARTAN_STYLES.includes(args.style)) {
+            return sendError(id, -32602, `Style inválido. Use: ${SPARTAN_STYLES.join(', ')}`);
+        }
+        const styleArg = args.style ? ` --style "${args.style}"` : '';
+        (0, child_process_1.exec)(`node "${cliPath}" init-ui${styleArg}`, (err, stdout, stderr) => {
+            sendResult(id, {
+                content: [{ type: 'text', text: err ? `Falha: ${stderr || err.message}` : stdout || 'Design system inicializado com sucesso.' }],
+                isError: !!err
+            });
+        });
+        // ── ds_set_spartan_style ──────────────────────────────────────────────────
+    }
+    else if (toolName === 'ds_set_spartan_style') {
+        const { style } = args;
+        if (!style)
+            return sendError(id, -32602, 'style é obrigatório');
+        if (!SPARTAN_STYLES.includes(style)) {
+            return sendError(id, -32602, `Style inválido. Use: ${SPARTAN_STYLES.join(', ')}`);
+        }
+        (0, child_process_1.exec)(`node "${cliPath}" ui:set-style "${style}"`, (err, stdout, stderr) => {
+            sendResult(id, {
+                content: [{ type: 'text', text: err ? `Falha: ${stderr || err.message}` : stdout || `Style alterado para ${style}.` }],
+                isError: !!err
+            });
+        });
+        // ── ds_new_project ────────────────────────────────────────────────────────
+    }
+    else if (toolName === 'ds_new_project') {
+        const { projectName } = args;
+        if (!projectName)
+            return sendError(id, -32602, 'projectName é obrigatório');
+        (0, child_process_1.exec)(`node "${cliPath}" new-project "${projectName}"`, { cwd: process.cwd() }, (err, stdout, stderr) => {
+            sendResult(id, {
+                content: [{ type: 'text', text: err ? `Falha: ${stderr || err.message}` : stdout || `Projeto "${projectName}" criado com sucesso!` }],
+                isError: !!err
+            });
+        });
+        // ── ds_generate_migration ─────────────────────────────────────────────────
+    }
+    else if (toolName === 'ds_generate_migration') {
+        const backendPath = args.backendPath || './backend';
+        const absoluteBackend = path.resolve(process.cwd(), backendPath);
+        if (!fs.existsSync(absoluteBackend)) {
+            return sendResult(id, {
+                content: [{ type: 'text', text: `Backend não encontrado em: ${absoluteBackend}` }],
+                isError: true
+            });
+        }
+        (0, child_process_1.exec)('npm run migration:generate', { cwd: absoluteBackend }, (err, stdout, stderr) => {
+            sendResult(id, {
+                content: [{ type: 'text', text: err ? `Falha na migration: ${stderr || err.message}` : stdout || 'Migration gerada com sucesso.' }],
+                isError: !!err
+            });
+        });
+        // ── ds_run_harnesses ──────────────────────────────────────────────────────
+    }
+    else if (toolName === 'ds_run_harnesses') {
+        // Tenta descobrir a raiz do monorepo DevKit instalado
+        const monorepoRoot = path.resolve(path.dirname(cliPath), '../../..');
+        (0, child_process_1.exec)('pnpm test', { cwd: monorepoRoot }, (err, stdout, stderr) => {
+            sendResult(id, {
+                content: [{ type: 'text', text: err ? `Testes falharam:\n${stderr || err.message}\n\n${stdout}` : stdout || 'Todos os harnesses passaram!' }],
+                isError: !!err
+            });
+        });
+    }
+    else {
+        sendError(id, -32601, `Ferramenta não encontrada: ${toolName}`);
+    }
+}

package/dist/integration.test.d.ts

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

package/dist/integration.test.js

@@ -0,0 +1,159 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const assert = __importStar(require("node:assert"));
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+(0, node_test_1.test)('MCP Server Integration Test', async (t) => {
+    const serverPath = path.resolve(__dirname, 'index.js');
+    const sandboxDir = path.resolve(__dirname, '../../../sandbox-test');
+    const cp = (0, child_process_1.spawn)('node', [serverPath], {
+        cwd: sandboxDir,
+        stdio: ['pipe', 'pipe', 'inherit']
+    });
+    const responses = [];
+    let buffer = '';
+    const onData = new Promise((resolve) => {
+        cp.stdout.on('data', (chunk) => {
+            buffer += chunk.toString();
+            let index;
+            while ((index = buffer.indexOf('\n')) !== -1) {
+                const line = buffer.substring(0, index).trim();
+                buffer = buffer.substring(index + 1);
+                if (line) {
+                    responses.push(line);
+                }
+            }
+        });
+        cp.on('close', () => resolve());
+    });
+    async function sendRequest(req) {
+        cp.stdin.write(JSON.stringify(req) + '\n');
+        const startTime = Date.now();
+        while (Date.now() - startTime < 10000) { // 10s timeout
+            for (let i = 0; i < responses.length; i++) {
+                try {
+                    const res = JSON.parse(responses[i]);
+                    if (res.id === req.id) {
+                        responses.splice(i, 1);
+                        return res;
+                    }
+                }
+                catch { }
+            }
+            await new Promise((r) => setTimeout(r, 100));
+        }
+        throw new Error(`Timeout waiting for response to request id ${req.id}`);
+    }
+    await t.test('should respond to initialize', async () => {
+        const res = await sendRequest({
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'initialize',
+            params: { protocolVersion: '2024-11-05' }
+        });
+        assert.strictEqual(res.jsonrpc, '2.0');
+        assert.strictEqual(res.id, 1);
+        assert.ok(res.result);
+        assert.strictEqual(res.result.protocolVersion, '2024-11-05');
+    });
+    await t.test('should list tools', async () => {
+        const res = await sendRequest({
+            jsonrpc: '2.0',
+            id: 2,
+            method: 'tools/list'
+        });
+        assert.strictEqual(res.id, 2);
+        assert.ok(res.result);
+        assert.ok(Array.isArray(res.result.tools));
+        const tools = res.result.tools.map((t) => t.name);
+        assert.ok(tools.includes('ds_list_entities'));
+        assert.ok(tools.includes('ds_check_architecture'));
+    });
+    await t.test('should call ds_list_entities', async () => {
+        const res = await sendRequest({
+            jsonrpc: '2.0',
+            id: 3,
+            method: 'tools/call',
+            params: {
+                name: 'ds_list_entities'
+            }
+        });
+        assert.strictEqual(res.id, 3);
+        assert.ok(res.result);
+        assert.ok(Array.isArray(res.result.content));
+        assert.strictEqual(res.result.content[0].type, 'text');
+        const entities = JSON.parse(res.result.content[0].text);
+        assert.ok(Array.isArray(entities));
+        assert.ok(entities.some((e) => e.name === 'cabin'), 'Should include cabin');
+    });
+    await t.test('should call ds_generate_crud', async () => {
+        const res = await sendRequest({
+            jsonrpc: '2.0',
+            id: 4,
+            method: 'tools/call',
+            params: {
+                name: 'ds_generate_crud',
+                arguments: {
+                    entityName: 'cabin'
+                }
+            }
+        });
+        assert.strictEqual(res.id, 4);
+        assert.ok(res.result);
+        assert.ok(Array.isArray(res.result.content));
+        assert.strictEqual(res.result.content[0].type, 'text');
+        assert.ok(res.result.content[0].text.includes('Scaffolding de CRUD completo para "cabin" finalizado!'));
+    });
+    await t.test('should call ds_check_architecture', async () => {
+        const res = await sendRequest({
+            jsonrpc: '2.0',
+            id: 5,
+            method: 'tools/call',
+            params: {
+                name: 'ds_check_architecture'
+            }
+        });
+        assert.strictEqual(res.id, 5);
+        assert.ok(res.result);
+        assert.strictEqual(res.result.isError, false);
+        assert.ok(res.result.content[0].text.includes('Varredura finalizada'));
+    });
+    // Cleanup
+    cp.stdin.end();
+    cp.kill();
+    await onData;
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@devstroupe/devkit-mcp",
+  "version": "1.0.0",
+  "description": "DevsTroupe Development Kit MCP Server — exposes CLI automation as native AI tools via Model Context Protocol",
+  "license": "MIT",
+  "keywords": [
+    "devstroupe",
+    "devkit",
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "llm",
+    "agent",
+    "tools",
+    "nestjs",
+    "angular"
+  ],
+  "homepage": "https://github.com/devstroupe/devkit#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/devstroupe/devkit.git",
+    "directory": "packages/devkit-mcp"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "main": "dist/index.js",
+  "bin": {
+    "devstroupe-mcp": "./dist/index.js"
+  },
+  "dependencies": {
+    "@devstroupe/devkit-cli": "^1.0.0",
+    "fs-extra": "^11.2.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.11.0",
+    "typescript": "^5.4.5"
+  },
+  "scripts": {
+    "build": "tsc && chmod +x dist/index.js",
+    "test": "tsc && node --test dist/integration.test.js"
+  }
+}