@matizze/prumo-mcp 0.0.0-stage → 0.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -1,3 +1,59 @@
1
- # Temporary Holding Version
1
+ # @matizze/prumo-mcp
2
2
 
3
- This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
3
+ Servidor MCP do Prumo: os comandos da CLI como ferramentas para agentes de IA.
4
+
5
+ **Situação:** uma ferramenta por comando do `prumo`, por stdio, com o bin `prumo-mcp`. A CLI tem `new`, `make:page`, `make:domain`, `make:component`, `check` e `doctor`, e o servidor expõe todos. Nada foi publicado: o pacote segue `"private": true`.
6
+
7
+ ## Como ligar
8
+
9
+ O servidor roda na máquina de quem usa o agente, na pasta do projeto, e fala por stdio. Ligue-o pelo `.mcp.json` da raiz do projeto (o que o Claude Code e outros clientes MCP leem):
10
+
11
+ ```json
12
+ {
13
+ "mcpServers": {
14
+ "prumo": { "command": "pnpm", "args": ["exec", "prumo-mcp"] }
15
+ }
16
+ }
17
+ ```
18
+
19
+ O `prumo-mcp` é o bin deste pacote, que o projeto tem como `devDependency`. Não o rode à mão: o stdout é o protocolo. `prumo-mcp --help` e `--version` escrevem a ajuda e a versão e saem.
20
+
21
+ ## As ferramentas
22
+
23
+ Uma ferramenta por comando, com o nome do comando com `:` trocado por `_`. Não há ferramenta escrita à mão: o nome, a descrição e o esquema de entrada saem da árvore de comandos da CLI (`describeCommands`), então um comando novo vira ferramenta sem mudar o servidor.
24
+
25
+ | Ferramenta | Comando | Campos |
26
+ | ---------------- | ---------------------- | ------------------------------------------------ |
27
+ | `check` | `prumo check` | `root` |
28
+ | `doctor` | `prumo doctor` | `root` |
29
+ | `make_component` | `prumo make:component` | `nome`, `page`, `shared`, `root` e `dry-run` |
30
+ | `make_domain` | `prumo make:domain` | `nome`, `entity`, `root` e `dry-run` |
31
+ | `make_page` | `prumo make:page` | `nome`, `domain`, `root` e `dry-run` |
32
+ | `new` | `prumo new` | `nome`, `dir`, `packages`, `install` e `dry-run` |
33
+
34
+ - **O nome do campo é o do argumento na CLI, sem tradução.** `toArgv`, da CLI, faz o mapa de campo para linha de comando. O esquema é derivado dos argumentos, e um campo que o comando não tem é recusado.
35
+ - **A saída é o texto da CLI, sem moldura:** o stdout e, depois, o stderr do comando, e, quando o código de saída não é 0, uma última linha `[saída <código>]`. `isError` é verdadeiro quando o código não é 0: o `check` com violação (saída 1) e o uso errado (saída 2) são erro da ferramenta, como no terminal.
36
+ - **O comando roda em processo** (`runInProcess`, de `@matizze/prumo-cli/api`), com o `cwd` da pasta onde o servidor roda e o ambiente do servidor.
37
+ - **Uma chamada de cada vez.** O cliente pode pedir várias juntas, mas dois comandos escrevendo no mesmo projeto se atropelariam, então o servidor as roda em fila.
38
+ - **O `new` pelo servidor** cria o app dentro da pasta do servidor (o `dir` é conferido como o `root`) e instala com o `pnpm install`, cuja saída volta no texto da ferramenta, nunca no stdout do processo (o do servidor é o protocolo). `install: false` só cria os arquivos.
39
+ - **O `root` e o `dir` ficam dentro da pasta do servidor.** Quem escolhe o valor é o agente, e `root: "/"` o levaria para fora do projeto. O servidor resolve os dois contra o `cwd` (seguindo links simbólicos) e recusa, com `isError` e sem rodar o comando, o que sai da pasta. É a única regra do servidor que não vem da CLI.
40
+
41
+ Só ferramentas: o servidor não expõe resources nem prompts, e o transporte é só stdio.
42
+
43
+ ## API
44
+
45
+ - `createServer({ cwd?, env?, commands? })`: monta o servidor (`McpServer` do SDK, nome `prumo`, versão do `package.json`) e devolve `{ server, tools }`, sem ligar a transporte. `commands` troca a árvore do `prumo` por outra lista de `CommandInfo`.
46
+ - `toolsOf(commands, { cwd, env? })`: uma `PrumoTool` por comando.
47
+ - `inputSchemaOf(command)`: o esquema zod da ferramenta de um comando.
48
+
49
+ ## Testes
50
+
51
+ Usam o cliente do SDK (`@modelcontextprotocol/client`, só de teste) contra um projeto mínimo numa pasta temporária: a paridade das ferramentas com a ajuda do `prumo` (o oráculo é a ajuda, não o `describeCommands`), o esquema de cada tipo de argumento, as chamadas (`check` com e sem violação, erro de uso, isolamento, fila, `root` e `dir` fora da pasta) e o bin por stdio (cada linha do stdout é JSON-RPC, e a saída dos comandos está nas respostas).
52
+
53
+ ## Build e empacotamento
54
+
55
+ No workspace, o `exports` e o `bin` apontam para o código-fonte (`src/*.ts`). O pacote tem `tsconfig.build.json` e o script `build`, que emite o `dist/`; o `publishConfig` troca `exports` e `bin` para ele, e o `@matizze/prumo-cli` (`workspace:*`) vira a versão exata no tarball. O `packaging.test.ts` do cli confere o tarball e sobe o `prumo-mcp` empacotado, com o `node` comum, para um `initialize` e um `tools/list` por stdio.
56
+
57
+ ## Dependências
58
+
59
+ `@modelcontextprotocol/server` (o SDK oficial, v2) e `zod` em `dependencies`, mais `@matizze/prumo-cli` (`workspace:*`); `@modelcontextprotocol/client` só em `devDependencies`, para os testes.
package/dist/bin.d.ts ADDED
@@ -0,0 +1,2 @@
1
+ #!/usr/bin/env node
2
+ export {};
package/dist/bin.js ADDED
@@ -0,0 +1,46 @@
1
+ #!/usr/bin/env node
2
+ import { serveStdio } from '@modelcontextprotocol/server/stdio';
3
+ import { PACKAGE_NAME, PACKAGE_VERSION } from "./package-info.js";
4
+ import { createServer } from "./server.js";
5
+ const HELP = `Uso: prumo-mcp
6
+
7
+ O servidor MCP do Prumo (${PACKAGE_NAME} ${PACKAGE_VERSION}): uma ferramenta por comando do
8
+ prumo (check, doctor e os make:*), por stdio. O servidor roda na pasta do projeto, e o stdout é o protocolo:
9
+ ligue-o ao agente pelo .mcp.json do projeto, não o rode à mão.
10
+
11
+ { "mcpServers": { "prumo": { "command": "pnpm", "args": ["exec", "prumo-mcp"] } } }
12
+
13
+ Opções:
14
+ -h, --help Mostra esta ajuda.
15
+ -v, --version Mostra a versão.
16
+ `;
17
+ const args = process.argv.slice(2);
18
+ if (args.includes('-h') || args.includes('--help')) {
19
+ process.stdout.write(HELP);
20
+ }
21
+ else if (args.includes('-v') || args.includes('--version')) {
22
+ process.stdout.write(`${PACKAGE_VERSION}\n`);
23
+ }
24
+ else if (args.length > 0) {
25
+ process.stderr.write(`prumo-mcp: opção desconhecida: '${args[0]}'.\n\n${HELP}`);
26
+ process.exitCode = 2;
27
+ }
28
+ else {
29
+ // O stdout é do protocolo: o que mais escrevesse no console o corromperia, então vai para o stderr
30
+ console.log = console.error;
31
+ console.info = console.error;
32
+ console.debug = console.error;
33
+ const fail = (error) => {
34
+ process.stderr.write(`prumo-mcp: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`);
35
+ process.exit(1);
36
+ };
37
+ try {
38
+ // Uma instância por conexão (o SDK a pede da fábrica); o stdio fecha quando o cliente fecha o stdin
39
+ serveStdio(async () => (await createServer()).server, {
40
+ onerror: (error) => process.stderr.write(`prumo-mcp: ${error.message}\n`),
41
+ });
42
+ }
43
+ catch (error) {
44
+ fail(error);
45
+ }
46
+ }
@@ -0,0 +1,8 @@
1
+ /**
2
+ * Ponto de entrada do @matizze/prumo-mcp: o servidor MCP do Prumo, uma ferramenta por comando da
3
+ * CLI. O bin `prumo-mcp` (`bin.ts`) liga o servidor ao stdio; aqui estão as peças, para os testes.
4
+ */
5
+ export { PACKAGE_NAME, PACKAGE_VERSION } from './package-info.js';
6
+ export { inputSchemaOf } from './schema.js';
7
+ export { createServer, type PrumoServer, type ServerOptions } from './server.js';
8
+ export { toolsOf, type PrumoTool, type ToolsOptions } from './tools.js';
package/dist/index.js ADDED
@@ -0,0 +1,8 @@
1
+ /**
2
+ * Ponto de entrada do @matizze/prumo-mcp: o servidor MCP do Prumo, uma ferramenta por comando da
3
+ * CLI. O bin `prumo-mcp` (`bin.ts`) liga o servidor ao stdio; aqui estão as peças, para os testes.
4
+ */
5
+ export { PACKAGE_NAME, PACKAGE_VERSION } from "./package-info.js";
6
+ export { inputSchemaOf } from "./schema.js";
7
+ export { createServer } from "./server.js";
8
+ export { toolsOf } from "./tools.js";
@@ -0,0 +1,4 @@
1
+ /** O nome do pacote, como está no `package.json`. */
2
+ export declare const PACKAGE_NAME: string;
3
+ /** A versão do pacote, que o servidor informa ao cliente. */
4
+ export declare const PACKAGE_VERSION: string;
@@ -0,0 +1,10 @@
1
+ import { readFileSync } from 'node:fs';
2
+ /**
3
+ * O `package.json` do mcp, lido na hora: o caminho `../package.json` é o mesmo a partir de `src/` e
4
+ * de `dist/`, então vale no workspace e no pacote publicado.
5
+ */
6
+ const info = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
7
+ /** O nome do pacote, como está no `package.json`. */
8
+ export const PACKAGE_NAME = info.name;
9
+ /** A versão do pacote, que o servidor informa ao cliente. */
10
+ export const PACKAGE_VERSION = info.version;
@@ -0,0 +1,12 @@
1
+ import type { CommandInfo } from '@matizze/prumo-cli/api';
2
+ import { z } from 'zod';
3
+ /**
4
+ * O esquema de entrada da ferramenta de um comando, derivado dos argumentos dele (nada à mão): um
5
+ * campo por argumento, com o nome que ele tem na CLI. Posicional de texto e opção de texto são
6
+ * `string` (o posicional, sem começar por `-`), o posicional variádico é uma lista com ao menos um
7
+ * item, liga e desliga é `boolean`, `enum` é a lista de valores aceitos, e o que o comando exige
8
+ * não é opcional. Um campo que o comando não tem é recusado.
9
+ */
10
+ export declare function inputSchemaOf(command: CommandInfo): z.ZodObject<{
11
+ [x: string]: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
12
+ }, z.core.$strict>;
package/dist/schema.js ADDED
@@ -0,0 +1,46 @@
1
+ import { z } from 'zod';
2
+ /** O que o campo de texto aceita: algo que não começa com `-`, que o parser da CLI leria como opção. */
3
+ const POSITIONAL_TEXT = z
4
+ .string()
5
+ .min(1, 'não pode ser vazio')
6
+ .regex(/^(?!-)/, "não pode começar com '-': o comando o leria como opção");
7
+ /** A descrição do campo: a da opção na CLI e, quando ela tem um, o valor de partida. */
8
+ function describeField(option) {
9
+ const text = option.description.trim();
10
+ if (option.default === undefined)
11
+ return text;
12
+ const standard = typeof option.default === 'boolean' ? (option.default ? 'ligada' : 'desligada') : option.default;
13
+ return `${text} (padrão: ${standard})`.trim();
14
+ }
15
+ /** O esquema de um campo, do tipo do argumento na CLI. O `optional` fica a cargo de quem chama. */
16
+ function fieldOf(option) {
17
+ switch (option.kind) {
18
+ case 'positional':
19
+ return option.variadic
20
+ ? z.array(POSITIONAL_TEXT).min(1, 'precisa de ao menos um')
21
+ : POSITIONAL_TEXT;
22
+ case 'boolean':
23
+ return z.boolean();
24
+ case 'enum':
25
+ return option.choices?.length
26
+ ? z.enum(option.choices)
27
+ : z.string().min(1, 'não pode ser vazio');
28
+ case 'string':
29
+ return z.string().min(1, 'não pode ser vazio');
30
+ }
31
+ }
32
+ /**
33
+ * O esquema de entrada da ferramenta de um comando, derivado dos argumentos dele (nada à mão): um
34
+ * campo por argumento, com o nome que ele tem na CLI. Posicional de texto e opção de texto são
35
+ * `string` (o posicional, sem começar por `-`), o posicional variádico é uma lista com ao menos um
36
+ * item, liga e desliga é `boolean`, `enum` é a lista de valores aceitos, e o que o comando exige
37
+ * não é opcional. Um campo que o comando não tem é recusado.
38
+ */
39
+ export function inputSchemaOf(command) {
40
+ const shape = {};
41
+ for (const option of command.options) {
42
+ const field = fieldOf(option).describe(describeField(option));
43
+ shape[option.name] = option.required ? field : field.optional();
44
+ }
45
+ return z.strictObject(shape);
46
+ }
@@ -0,0 +1,23 @@
1
+ import { type CommandInfo } from '@matizze/prumo-cli/api';
2
+ import { McpServer } from '@modelcontextprotocol/server';
3
+ import { type PrumoTool } from './tools.js';
4
+ /** Como o servidor é montado: tudo opcional, e os padrões são os do bin. */
5
+ export interface ServerOptions {
6
+ /** A pasta do projeto: o cwd dos comandos e o limite do `root` e do `dir`. Padrão: `process.cwd()`. */
7
+ cwd?: string;
8
+ /** O ambiente dos comandos. Padrão: `process.env`. */
9
+ env?: Readonly<Record<string, string | undefined>>;
10
+ /** Os comandos a expor. Padrão: a árvore do `prumo` (`describeCommands(createRoot(...))`). */
11
+ commands?: readonly CommandInfo[];
12
+ }
13
+ /** O servidor e as ferramentas que ele registrou. */
14
+ export interface PrumoServer {
15
+ server: McpServer;
16
+ tools: PrumoTool[];
17
+ }
18
+ /**
19
+ * Monta o servidor MCP do Prumo (nome `prumo`, versão do pacote): uma ferramenta por comando da CLI,
20
+ * e nada além disso (sem resources nem prompts). Não liga a transporte nenhum; o `bin.ts` liga o
21
+ * stdio e os testes ligam o que quiserem.
22
+ */
23
+ export declare function createServer(options?: ServerOptions): Promise<PrumoServer>;
package/dist/server.js ADDED
@@ -0,0 +1,28 @@
1
+ import { createRoot, describeCommands } from '@matizze/prumo-cli/api';
2
+ import { McpServer } from '@modelcontextprotocol/server';
3
+ import { PACKAGE_VERSION } from "./package-info.js";
4
+ import { toolsOf } from "./tools.js";
5
+ /** A árvore do `prumo` como dado. O Runtime é de mentira: descrever não roda comando. */
6
+ async function prumoCommands() {
7
+ const unused = () => {
8
+ throw new Error('descrever os comandos não os roda');
9
+ };
10
+ return describeCommands(createRoot({ out: unused, err: unused, cwd: '/', env: {} }));
11
+ }
12
+ /**
13
+ * Monta o servidor MCP do Prumo (nome `prumo`, versão do pacote): uma ferramenta por comando da CLI,
14
+ * e nada além disso (sem resources nem prompts). Não liga a transporte nenhum; o `bin.ts` liga o
15
+ * stdio e os testes ligam o que quiserem.
16
+ */
17
+ export async function createServer(options = {}) {
18
+ const commands = options.commands ?? (await prumoCommands());
19
+ const tools = toolsOf(commands, {
20
+ cwd: options.cwd ?? process.cwd(),
21
+ env: options.env ?? process.env,
22
+ });
23
+ const server = new McpServer({ name: 'prumo', version: PACKAGE_VERSION });
24
+ for (const tool of tools) {
25
+ server.registerTool(tool.name, { description: tool.description, inputSchema: tool.inputSchema }, (input) => tool.call(input));
26
+ }
27
+ return { server, tools };
28
+ }
@@ -0,0 +1,33 @@
1
+ import { type CommandInfo } from '@matizze/prumo-cli/api';
2
+ import type { CallToolResult } from '@modelcontextprotocol/server';
3
+ import { inputSchemaOf } from './schema.js';
4
+ /** Onde e com que ambiente as ferramentas rodam os comandos. */
5
+ export interface ToolsOptions {
6
+ /** A pasta do servidor: o cwd dos comandos, e o limite do `root` e do `dir`. */
7
+ cwd: string;
8
+ /** As variáveis de ambiente dos comandos (`PATH` para o `pnpm`, `HOME`). */
9
+ env?: Readonly<Record<string, string | undefined>>;
10
+ }
11
+ /** Uma ferramenta MCP, a projeção de um comando da CLI. */
12
+ export interface PrumoTool {
13
+ /** O nome da ferramenta: o do comando com `:` trocado por `_` (`make_page`). */
14
+ name: string;
15
+ /** A descrição inteira do comando, a mesma da ajuda. */
16
+ description: string;
17
+ /** O comando que a ferramenta roda. */
18
+ command: CommandInfo;
19
+ /** O esquema de entrada, derivado dos argumentos do comando. */
20
+ inputSchema: ReturnType<typeof inputSchemaOf>;
21
+ /** Roda o comando com os campos dados e devolve o texto dele. */
22
+ call: (input: Readonly<Record<string, unknown>>) => Promise<CallToolResult>;
23
+ }
24
+ /**
25
+ * Uma ferramenta por comando: o servidor não tem lógica de comando. O nome, a descrição e o esquema
26
+ * saem do `CommandInfo`; a chamada vira a linha de comando (`toArgv`, a função da CLI) e roda em
27
+ * processo (`runInProcess`), com o `cwd` e o ambiente do servidor. O código de saída que não é 0
28
+ * (violação do `check`, uso errado) é `isError`, e o agente lê o motivo no texto.
29
+ *
30
+ * As chamadas rodam uma de cada vez: dois comandos que escrevem no mesmo projeto ao mesmo tempo
31
+ * (duas telas no `App.tsx`, por exemplo) se atropelariam, e o cliente pode pedir várias juntas.
32
+ */
33
+ export declare function toolsOf(commands: readonly CommandInfo[], options: ToolsOptions): PrumoTool[];
package/dist/tools.js ADDED
@@ -0,0 +1,105 @@
1
+ import { existsSync, realpathSync } from 'node:fs';
2
+ import path from 'node:path';
3
+ import { runInProcess, toArgv } from '@matizze/prumo-cli/api';
4
+ import { inputSchemaOf } from "./schema.js";
5
+ /**
6
+ * Os campos que dizem uma pasta onde o comando escreve: ficam dentro da pasta do servidor. O `dir`
7
+ * é o do `new`, que volta com os geradores: a regra vale para qualquer comando que o tenha.
8
+ */
9
+ const FOLDER_FIELDS = ['root', 'dir'];
10
+ /** Resolve os links simbólicos da parte do caminho que já existe, para o `..` e o link não escaparem. */
11
+ function realPathOf(target) {
12
+ let existing = target;
13
+ const missing = [];
14
+ while (!existsSync(existing)) {
15
+ const parent = path.dirname(existing);
16
+ if (parent === existing)
17
+ break;
18
+ missing.unshift(path.basename(existing));
19
+ existing = parent;
20
+ }
21
+ return path.join(realpathSync(existing), ...missing);
22
+ }
23
+ function isInside(folder, target) {
24
+ const relative = path.relative(realPathOf(folder), realPathOf(target));
25
+ return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
26
+ }
27
+ /**
28
+ * Confere que `root` e `dir` ficam dentro da pasta do servidor. Quem escolhe o valor é o agente, e
29
+ * `--root /` ou `--dir ~` o levaria a escrever fora do projeto. É a única regra do servidor que não
30
+ * vem da CLI: existe por segurança. Devolve a mensagem de erro, ou `undefined` se está tudo dentro.
31
+ */
32
+ function outsideFolder(input, cwd) {
33
+ for (const field of FOLDER_FIELDS) {
34
+ const value = input[field];
35
+ if (typeof value !== 'string' || value === '')
36
+ continue;
37
+ if (!isInside(cwd, path.resolve(cwd, value))) {
38
+ return `o campo '${field}' ('${value}') fica fora da pasta do servidor (${cwd}): o servidor MCP só escreve dentro dela. Para outro lugar, rode o prumo no terminal.`;
39
+ }
40
+ }
41
+ return undefined;
42
+ }
43
+ /**
44
+ * O texto de uma ferramenta, sem moldura: o stdout e, depois, o stderr do comando, na ordem, e, se o
45
+ * código de saída não é 0, uma última linha `[saída <código>]`.
46
+ */
47
+ function textOf(exitCode, stdout, stderr) {
48
+ const parts = [stdout, stderr].filter((part) => part !== '');
49
+ const text = parts.map((part) => (part.endsWith('\n') ? part : `${part}\n`)).join('');
50
+ if (exitCode !== 0)
51
+ return `${text}[saída ${exitCode}]`;
52
+ return text === '' ? '(sem saída)' : text;
53
+ }
54
+ function resultOf(exitCode, stdout, stderr) {
55
+ return {
56
+ content: [{ type: 'text', text: textOf(exitCode, stdout, stderr) }],
57
+ isError: exitCode !== 0,
58
+ };
59
+ }
60
+ /**
61
+ * Uma ferramenta por comando: o servidor não tem lógica de comando. O nome, a descrição e o esquema
62
+ * saem do `CommandInfo`; a chamada vira a linha de comando (`toArgv`, a função da CLI) e roda em
63
+ * processo (`runInProcess`), com o `cwd` e o ambiente do servidor. O código de saída que não é 0
64
+ * (violação do `check`, uso errado) é `isError`, e o agente lê o motivo no texto.
65
+ *
66
+ * As chamadas rodam uma de cada vez: dois comandos que escrevem no mesmo projeto ao mesmo tempo
67
+ * (duas telas no `App.tsx`, por exemplo) se atropelariam, e o cliente pode pedir várias juntas.
68
+ */
69
+ export function toolsOf(commands, options) {
70
+ let queue = Promise.resolve();
71
+ const serial = (task) => {
72
+ const next = queue.then(task, task);
73
+ queue = next.catch(() => undefined);
74
+ return next;
75
+ };
76
+ return commands.map((command) => ({
77
+ name: command.toolName,
78
+ description: command.description,
79
+ command,
80
+ inputSchema: inputSchemaOf(command),
81
+ call: (input) => serial(async () => {
82
+ const outside = outsideFolder(input, options.cwd);
83
+ if (outside)
84
+ return resultOf(2, '', `${outside}\n`);
85
+ let argv;
86
+ try {
87
+ argv = [...command.path, ...toArgv(command, input)];
88
+ }
89
+ catch (error) {
90
+ return resultOf(2, '', `${error instanceof Error ? error.message : String(error)}\n`);
91
+ }
92
+ try {
93
+ const { exitCode, stdout, stderr } = await runInProcess(argv, {
94
+ cwd: options.cwd,
95
+ ...(options.env === undefined ? {} : { env: options.env }),
96
+ });
97
+ return resultOf(exitCode, stdout, stderr);
98
+ }
99
+ catch (error) {
100
+ // O runCli devolve o erro inesperado como código 1; isto cobre o que escapar dele
101
+ return resultOf(1, '', `${error instanceof Error ? error.message : String(error)}\n`);
102
+ }
103
+ }),
104
+ }));
105
+ }
package/package.json CHANGED
@@ -1,6 +1,43 @@
1
1
  {
2
2
  "name": "@matizze/prumo-mcp",
3
- "version": "0.0.0-stage",
4
- "stub": true,
5
- "description": "Temporary package placeholder for staged publishing"
3
+ "version": "0.1.2",
4
+ "description": "Servidor MCP do Prumo: os comandos da CLI como ferramentas para agentes de IA.",
5
+ "repository": {
6
+ "type": "git",
7
+ "url": "git+https://github.com/matizze/prumo.git",
8
+ "directory": "packages/mcp"
9
+ },
10
+ "type": "module",
11
+ "bin": {
12
+ "prumo-mcp": "./dist/bin.js"
13
+ },
14
+ "exports": {
15
+ ".": {
16
+ "types": "./dist/index.d.ts",
17
+ "default": "./dist/index.js"
18
+ }
19
+ },
20
+ "files": [
21
+ "dist"
22
+ ],
23
+ "publishConfig": {
24
+ "registry": "https://registry.npmjs.org",
25
+ "access": "public"
26
+ },
27
+ "dependencies": {
28
+ "@modelcontextprotocol/server": "^2.4.0",
29
+ "zod": "^4.6.7",
30
+ "@matizze/prumo-cli": "0.5.1"
31
+ },
32
+ "devDependencies": {
33
+ "@modelcontextprotocol/client": "^2.4.0",
34
+ "@types/node": "^24.19.2",
35
+ "typescript": "~6.0.3",
36
+ "vitest": "^5.1.0"
37
+ },
38
+ "scripts": {
39
+ "build": "rm -rf dist && tsc -p tsconfig.build.json && node ../../scripts/rewrite-dts-imports.mjs dist",
40
+ "typecheck": "tsc",
41
+ "test": "vitest run"
42
+ }
6
43
  }