@matizze/prumo-cli 0.0.0-stage → 0.5.0
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 +120 -2
- package/dist/api.d.ts +10 -0
- package/dist/api.js +9 -0
- package/dist/args.d.ts +11 -0
- package/dist/args.js +61 -0
- package/dist/bin.d.ts +2 -0
- package/dist/bin.js +11 -0
- package/dist/codemod/add-route.d.ts +66 -0
- package/dist/codemod/add-route.js +435 -0
- package/dist/codemod/edit.d.ts +35 -0
- package/dist/codemod/edit.js +51 -0
- package/dist/codemod/index.d.ts +8 -0
- package/dist/codemod/index.js +8 -0
- package/dist/codemod/merge-barrel.d.ts +9 -0
- package/dist/codemod/merge-barrel.js +49 -0
- package/dist/codemod/messages.d.ts +11 -0
- package/dist/codemod/messages.js +46 -0
- package/dist/codemod/names.d.ts +62 -0
- package/dist/codemod/names.js +204 -0
- package/dist/codemod/plan.d.ts +45 -0
- package/dist/codemod/plan.js +147 -0
- package/dist/codemod/register-domain.d.ts +51 -0
- package/dist/codemod/register-domain.js +237 -0
- package/dist/codemod/register-messages.d.ts +11 -0
- package/dist/codemod/register-messages.js +112 -0
- package/dist/codemod/route-elements.d.ts +25 -0
- package/dist/codemod/route-elements.js +72 -0
- package/dist/commands/check.d.ts +16 -0
- package/dist/commands/check.js +47 -0
- package/dist/commands/doctor.d.ts +20 -0
- package/dist/commands/doctor.js +104 -0
- package/dist/commands/make-component.d.ts +33 -0
- package/dist/commands/make-component.js +85 -0
- package/dist/commands/make-domain.d.ts +30 -0
- package/dist/commands/make-domain.js +83 -0
- package/dist/commands/make-page.d.ts +30 -0
- package/dist/commands/make-page.js +73 -0
- package/dist/commands/new.d.ts +33 -0
- package/dist/commands/new.js +179 -0
- package/dist/commands/shared.d.ts +43 -0
- package/dist/commands/shared.js +83 -0
- package/dist/describe.d.ts +63 -0
- package/dist/describe.js +134 -0
- package/dist/doctor/checks.d.ts +35 -0
- package/dist/doctor/checks.js +283 -0
- package/dist/doctor/ranges.d.ts +16 -0
- package/dist/doctor/ranges.js +27 -0
- package/dist/doctor/versions.d.ts +33 -0
- package/dist/doctor/versions.js +44 -0
- package/dist/errors.d.ts +12 -0
- package/dist/errors.js +19 -0
- package/dist/generate/app.d.ts +27 -0
- package/dist/generate/app.js +136 -0
- package/dist/generate/component.d.ts +36 -0
- package/dist/generate/component.js +48 -0
- package/dist/generate/domain.d.ts +31 -0
- package/dist/generate/domain.js +63 -0
- package/dist/generate/page.d.ts +45 -0
- package/dist/generate/page.js +100 -0
- package/dist/help.d.ts +19 -0
- package/dist/help.js +97 -0
- package/dist/in-process.d.ts +26 -0
- package/dist/in-process.js +23 -0
- package/dist/index.d.ts +9 -0
- package/dist/index.js +9 -0
- package/dist/new/name.d.ts +7 -0
- package/dist/new/name.js +24 -0
- package/dist/new/packages.d.ts +6 -0
- package/dist/new/packages.js +40 -0
- package/dist/new/versions.d.ts +7 -0
- package/dist/new/versions.js +13 -0
- package/dist/process.d.ts +22 -0
- package/dist/process.js +45 -0
- package/dist/project.d.ts +22 -0
- package/dist/project.js +42 -0
- package/dist/root.d.ts +3 -0
- package/dist/root.js +24 -0
- package/dist/run.d.ts +13 -0
- package/dist/run.js +72 -0
- package/dist/runtime.d.ts +19 -0
- package/dist/runtime.js +1 -0
- package/dist/templates.d.ts +26 -0
- package/dist/templates.js +46 -0
- package/package.json +45 -3
- package/templates/app/AGENTS.md.tpl +50 -0
- package/templates/app/README.md.tpl +15 -0
- package/templates/app/eslint.config.js.tpl +19 -0
- package/templates/app/gitignore.tpl +22 -0
- package/templates/app/index.html.tpl +12 -0
- package/templates/app/mcp.json.tpl +8 -0
- package/templates/app/src/App.tsx.tpl +8 -0
- package/templates/app/src/i18n.ts.tpl +12 -0
- package/templates/app/src/main.tsx.tpl +12 -0
- package/templates/app/src/messages/index.ts.tpl +1 -0
- package/templates/app/src/providers/app.tsx.tpl +23 -0
- package/templates/app/src/providers/repository/index.ts.tpl +5 -0
- package/templates/app/src/queries-index.ts.tpl +1 -0
- package/templates/app/src/repositories/index.ts.tpl +18 -0
- package/templates/app/src/repositories/options.ts.tpl +8 -0
- package/templates/app/src/schemas-index.ts.tpl +1 -0
- package/templates/app/src/test/render.tsx.tpl +31 -0
- package/templates/app/src/test/setup.ts.tpl +4 -0
- package/templates/app/typescript.json.tpl +24 -0
- package/templates/app/vite.config.ts.tpl +16 -0
- package/templates/component/component-test.tsx.tpl +9 -0
- package/templates/component/component.tsx.tpl +11 -0
- package/templates/domain/queries.ts.tpl +62 -0
- package/templates/domain/repository-contract-test.ts.tpl +75 -0
- package/templates/domain/repository-contract.ts.tpl +13 -0
- package/templates/domain/repository-fixtures.ts.tpl +8 -0
- package/templates/domain/repository-index.ts.tpl +12 -0
- package/templates/domain/repository-mock.ts.tpl +69 -0
- package/templates/domain/schema.ts.tpl +23 -0
- package/templates/page/index-domain-test.tsx.tpl +11 -0
- package/templates/page/index-test.tsx.tpl +10 -0
- package/templates/page/index.tsx.tpl +7 -0
- package/templates/page/messages-domain.en.json.tpl +5 -0
- package/templates/page/messages-domain.pt-BR.json.tpl +5 -0
- package/templates/page/messages.en.json.tpl +3 -0
- package/templates/page/messages.pt-BR.json.tpl +3 -0
- package/templates/page/model-domain.ts.tpl +17 -0
- package/templates/page/model.ts.tpl +8 -0
- package/templates/page/view-domain.tsx.tpl +20 -0
- package/templates/page/view.tsx.tpl +9 -0
|
@@ -0,0 +1,83 @@
|
|
|
1
|
+
import { existsSync, readFileSync } from 'node:fs';
|
|
2
|
+
import path from 'node:path';
|
|
3
|
+
import { check } from '@matizze/prumo-rules/check';
|
|
4
|
+
import { ExitError } from "../errors.js";
|
|
5
|
+
import { formatViolation } from "./check.js";
|
|
6
|
+
/** A lista de arquivos de um grupo, um por linha, com o título e a contagem. */
|
|
7
|
+
function section(title, files) {
|
|
8
|
+
if (files.length === 0)
|
|
9
|
+
return '';
|
|
10
|
+
return `${title} (${files.length}):\n${files.map((file) => ` ${file}`).join('\n')}\n`;
|
|
11
|
+
}
|
|
12
|
+
/** O que o plano criou e alterou, em texto. `dryRun` troca os verbos para o futuro do pretérito. */
|
|
13
|
+
export function formatSummary({ created, modified }, dryRun) {
|
|
14
|
+
const [made, changed] = dryRun ? ['Seriam criados', 'Seriam alterados'] : ['Criados', 'Alterados'];
|
|
15
|
+
return [section(made, created), section(changed, modified)].filter(Boolean).join('\n');
|
|
16
|
+
}
|
|
17
|
+
/** Se o projeto tem o script do `package.json` (`test` roda o Vitest do projeto). */
|
|
18
|
+
function hasScript(project, script) {
|
|
19
|
+
const file = path.join(project.root, 'package.json');
|
|
20
|
+
if (!existsSync(file))
|
|
21
|
+
return false;
|
|
22
|
+
try {
|
|
23
|
+
const scripts = JSON.parse(readFileSync(file, 'utf8'))
|
|
24
|
+
.scripts;
|
|
25
|
+
return typeof scripts?.[script] === 'string';
|
|
26
|
+
}
|
|
27
|
+
catch {
|
|
28
|
+
return false;
|
|
29
|
+
}
|
|
30
|
+
}
|
|
31
|
+
/**
|
|
32
|
+
* O caminho como o shell o lê: sem mudança se só tem caracteres seguros, e entre aspas simples
|
|
33
|
+
* (com `'` escrito como `'\''`) se tem espaço ou outro caractere especial. Sem isso, o comando
|
|
34
|
+
* impresso, copiado para o terminal, quebraria num projeto com espaço no caminho.
|
|
35
|
+
*/
|
|
36
|
+
export function shellQuote(value) {
|
|
37
|
+
if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(value))
|
|
38
|
+
return value;
|
|
39
|
+
return `'${value.replaceAll("'", `'\\''`)}'`;
|
|
40
|
+
}
|
|
41
|
+
/**
|
|
42
|
+
* O comando do `pnpm` para o projeto, no mesmo terminal onde o comando do `prumo` rodou: `pnpm
|
|
43
|
+
* <comando>` na pasta do projeto e, fora dela, `pnpm --dir <pasta> <comando>`. Fora da pasta atual,
|
|
44
|
+
* o caminho absoluto é mais claro que uma subida de várias pastas.
|
|
45
|
+
*/
|
|
46
|
+
export function pnpmCommand(project, cwd, command) {
|
|
47
|
+
const relative = path.relative(cwd, project.root);
|
|
48
|
+
if (relative === '')
|
|
49
|
+
return `pnpm ${command}`;
|
|
50
|
+
return `pnpm --dir ${shellQuote(relative.startsWith('..') ? project.root : relative)} ${command}`;
|
|
51
|
+
}
|
|
52
|
+
/**
|
|
53
|
+
* O comando que roda os testes de uma pasta ou de um arquivo do projeto (`src/pages/produtos`),
|
|
54
|
+
* para o mesmo terminal onde o `make:*` rodou: usa o script `test` do projeto, se houver, e o
|
|
55
|
+
* Vitest direto, se não.
|
|
56
|
+
*/
|
|
57
|
+
export function testCommandFor(project, cwd, target) {
|
|
58
|
+
const run = hasScript(project, 'test') ? `test ${target}` : `exec vitest run ${target}`;
|
|
59
|
+
return pnpmCommand(project, cwd, run);
|
|
60
|
+
}
|
|
61
|
+
/**
|
|
62
|
+
* O fim de um comando `make:*`: roda o `prumo check` no projeto e escreve o resultado, seguido do
|
|
63
|
+
* `next` (o que fazer agora). Sem violação, sai normalmente. Com violação, escreve cada uma no
|
|
64
|
+
* stderr e sai com 1, já com os arquivos gerados (`generated`: `a tela foi gerada`). As violações
|
|
65
|
+
* que `expected` reconhece não contam como falha: o comando as mostra e explica.
|
|
66
|
+
*/
|
|
67
|
+
export function finishWithCheck(runtime, project, { generated, next, expected }) {
|
|
68
|
+
const violations = check({ root: project.root });
|
|
69
|
+
const known = expected ? violations.filter(expected.matches) : [];
|
|
70
|
+
const found = violations.filter((violation) => !known.includes(violation));
|
|
71
|
+
if (found.length === 0) {
|
|
72
|
+
if (expected && known.length > 0) {
|
|
73
|
+
runtime.out(`prumo check: ${expected.intro}\n${known.map(formatViolation).join('\n')}\n${expected.note}\n\n${next}`);
|
|
74
|
+
}
|
|
75
|
+
else
|
|
76
|
+
runtime.out(`prumo check: nenhuma violação.\n\n${next}`);
|
|
77
|
+
return;
|
|
78
|
+
}
|
|
79
|
+
const total = found.length === 1 ? '1 violação' : `${found.length} violações`;
|
|
80
|
+
runtime.err(`prumo check: ${total} (${generated}, e os arquivos ficaram no projeto):\n${found.map(formatViolation).join('\n')}\n`);
|
|
81
|
+
runtime.out(`\n${next}`);
|
|
82
|
+
throw new ExitError(1);
|
|
83
|
+
}
|
|
@@ -0,0 +1,63 @@
|
|
|
1
|
+
import { type AnyCommand } from './help.js';
|
|
2
|
+
/** Como o argumento se escreve na linha de comando. */
|
|
3
|
+
export type OptionKind = 'positional' | 'string' | 'boolean' | 'enum';
|
|
4
|
+
/** Um argumento de um comando (posicional ou opção), como dado. */
|
|
5
|
+
export interface OptionInfo {
|
|
6
|
+
/** O nome do argumento na CLI, sem tradução: `dry-run`, `nome`, e `item` para o posicional `item...`. */
|
|
7
|
+
name: string;
|
|
8
|
+
kind: OptionKind;
|
|
9
|
+
required: boolean;
|
|
10
|
+
/** O posicional que aceita vários valores (`item...`). */
|
|
11
|
+
variadic: boolean;
|
|
12
|
+
description: string;
|
|
13
|
+
/** A dica do valor na ajuda (`pasta`), se o comando a dá. */
|
|
14
|
+
valueHint?: string;
|
|
15
|
+
/** Os valores aceitos de uma opção `enum`. */
|
|
16
|
+
choices?: string[];
|
|
17
|
+
/** O valor de partida, se o comando tem um (a opção `install` do `new` parte ligada). */
|
|
18
|
+
default?: string | boolean;
|
|
19
|
+
/** Os apelidos da opção (`h` de `--help`), sem os traços. */
|
|
20
|
+
aliases: string[];
|
|
21
|
+
}
|
|
22
|
+
/** Um comando folha da árvore do `prumo`, como dado. */
|
|
23
|
+
export interface CommandInfo {
|
|
24
|
+
/** O nome como se digita: `make:page`. Num grupo de comandos, os nomes do caminho separados por espaço. */
|
|
25
|
+
name: string;
|
|
26
|
+
/** O caminho até o comando, a partir da raiz: `['make:page']`. */
|
|
27
|
+
path: string[];
|
|
28
|
+
/** O nome da ferramenta MCP do comando: `make_page` (veja `toolNameOf`). */
|
|
29
|
+
toolName: string;
|
|
30
|
+
/** A primeira linha da descrição, o que a lista de comandos mostra. */
|
|
31
|
+
summary: string;
|
|
32
|
+
/** A descrição inteira, a mesma da ajuda. */
|
|
33
|
+
description: string;
|
|
34
|
+
/** Os argumentos, na ordem em que o comando os declara. */
|
|
35
|
+
options: OptionInfo[];
|
|
36
|
+
}
|
|
37
|
+
/**
|
|
38
|
+
* O nome da ferramenta MCP de um comando: o nome com `:` (e o espaço de um grupo de comandos)
|
|
39
|
+
* trocado por `_`, `make:page` vira `make_page`. É a única função que dá nome a ferramenta.
|
|
40
|
+
*/
|
|
41
|
+
export declare function toolNameOf(commandName: string): string;
|
|
42
|
+
/**
|
|
43
|
+
* A árvore de comandos como dado, das mesmas definições do citty que a ajuda lê (o texto não é
|
|
44
|
+
* duplicado). Só os comandos folha, sem os `hidden`, na ordem de declaração. Recebe a raiz (o
|
|
45
|
+
* resultado de `createRoot`) em vez de importá-la, e assim não cria um import circular.
|
|
46
|
+
*/
|
|
47
|
+
export declare function describeCommands(root: AnyCommand): Promise<CommandInfo[]>;
|
|
48
|
+
/**
|
|
49
|
+
* Os argumentos de uma chamada (um campo por argumento, com o nome que ele tem na CLI) como linha de
|
|
50
|
+
* comando, para o `runCli`. É o mapa de campo para argv, e o único: o servidor MCP não traduz nada.
|
|
51
|
+
* Não leva o nome do comando: a linha inteira é `[...command.path, ...toArgv(command, input)]`.
|
|
52
|
+
*
|
|
53
|
+
* - posicional: o valor, na ordem do comando (o variádico recebe uma lista e vira um valor por item);
|
|
54
|
+
* um valor que começa com `-` é recusado, porque o parser o leria como opção;
|
|
55
|
+
* - opção de texto e `enum`: `--nome=valor`, uma forma só, que dispensa a separação por espaço e não
|
|
56
|
+
* deixa um valor que começa com `-` virar opção;
|
|
57
|
+
* - liga e desliga: `--nome` se verdadeira; se falsa, `--no-nome` quando o padrão dela é ligado (a
|
|
58
|
+
* `install` do `new`) e nada quando é desligado.
|
|
59
|
+
*
|
|
60
|
+
* Campo que o comando não tem, valor de outro tipo e posicional pulado são `UsageError`. O que falta
|
|
61
|
+
* de obrigatório e o valor fora da lista de um `enum` a conferência do `runCli` (`validateArgs`) acusa.
|
|
62
|
+
*/
|
|
63
|
+
export declare function toArgv(command: CommandInfo, input: Readonly<Record<string, unknown>>): string[];
|
package/dist/describe.js
ADDED
|
@@ -0,0 +1,134 @@
|
|
|
1
|
+
import { UsageError } from "./errors.js";
|
|
2
|
+
import { aliasesOf, isRequired, isVariadic, resolveValue, summary, } from "./help.js";
|
|
3
|
+
/**
|
|
4
|
+
* O nome da ferramenta MCP de um comando: o nome com `:` (e o espaço de um grupo de comandos)
|
|
5
|
+
* trocado por `_`, `make:page` vira `make_page`. É a única função que dá nome a ferramenta.
|
|
6
|
+
*/
|
|
7
|
+
export function toolNameOf(commandName) {
|
|
8
|
+
return commandName.replace(/[: ]+/g, '_');
|
|
9
|
+
}
|
|
10
|
+
function kindOf(def) {
|
|
11
|
+
return def.type === 'positional' || def.type === 'boolean' || def.type === 'enum'
|
|
12
|
+
? def.type
|
|
13
|
+
: 'string';
|
|
14
|
+
}
|
|
15
|
+
function describeOption(name, def) {
|
|
16
|
+
const variadic = def.type === 'positional' && isVariadic(name);
|
|
17
|
+
return {
|
|
18
|
+
name: variadic ? name.slice(0, -3) : name,
|
|
19
|
+
kind: kindOf(def),
|
|
20
|
+
required: isRequired(def),
|
|
21
|
+
variadic,
|
|
22
|
+
description: def.description ?? '',
|
|
23
|
+
...(def.valueHint === undefined ? {} : { valueHint: def.valueHint }),
|
|
24
|
+
...(def.type === 'enum' && def.options?.length ? { choices: [...def.options] } : {}),
|
|
25
|
+
...(def.default === undefined ? {} : { default: def.default }),
|
|
26
|
+
aliases: aliasesOf(def),
|
|
27
|
+
};
|
|
28
|
+
}
|
|
29
|
+
async function collect(command, commandPath, rootName, into) {
|
|
30
|
+
const entries = Object.entries(await resolveValue(command.subCommands ?? {}));
|
|
31
|
+
if (entries.length > 0) {
|
|
32
|
+
for (const [name, sub] of entries) {
|
|
33
|
+
const resolved = await resolveValue(sub);
|
|
34
|
+
if ((await resolveValue(resolved.meta ?? {})).hidden)
|
|
35
|
+
continue;
|
|
36
|
+
await collect(resolved, [...commandPath, name], rootName, into);
|
|
37
|
+
}
|
|
38
|
+
return;
|
|
39
|
+
}
|
|
40
|
+
const meta = await resolveValue(command.meta ?? {});
|
|
41
|
+
const name = commandPath.length === 0 ? rootName : commandPath.join(' ');
|
|
42
|
+
const args = Object.entries(await resolveValue(command.args ?? {}));
|
|
43
|
+
into.push({
|
|
44
|
+
name,
|
|
45
|
+
path: commandPath,
|
|
46
|
+
toolName: toolNameOf(name),
|
|
47
|
+
summary: summary(meta.description),
|
|
48
|
+
description: meta.description ?? '',
|
|
49
|
+
options: args.map(([argName, def]) => describeOption(argName, def)),
|
|
50
|
+
});
|
|
51
|
+
}
|
|
52
|
+
/**
|
|
53
|
+
* A árvore de comandos como dado, das mesmas definições do citty que a ajuda lê (o texto não é
|
|
54
|
+
* duplicado). Só os comandos folha, sem os `hidden`, na ordem de declaração. Recebe a raiz (o
|
|
55
|
+
* resultado de `createRoot`) em vez de importá-la, e assim não cria um import circular.
|
|
56
|
+
*/
|
|
57
|
+
export async function describeCommands(root) {
|
|
58
|
+
const rootName = (await resolveValue(root.meta ?? {})).name ?? 'prumo';
|
|
59
|
+
const commands = [];
|
|
60
|
+
await collect(root, [], rootName, commands);
|
|
61
|
+
return commands;
|
|
62
|
+
}
|
|
63
|
+
function textOf(value, field, what) {
|
|
64
|
+
if (typeof value !== 'string')
|
|
65
|
+
throw new UsageError(`'${field}' precisa ser ${what}.`);
|
|
66
|
+
return value;
|
|
67
|
+
}
|
|
68
|
+
/**
|
|
69
|
+
* Os argumentos de uma chamada (um campo por argumento, com o nome que ele tem na CLI) como linha de
|
|
70
|
+
* comando, para o `runCli`. É o mapa de campo para argv, e o único: o servidor MCP não traduz nada.
|
|
71
|
+
* Não leva o nome do comando: a linha inteira é `[...command.path, ...toArgv(command, input)]`.
|
|
72
|
+
*
|
|
73
|
+
* - posicional: o valor, na ordem do comando (o variádico recebe uma lista e vira um valor por item);
|
|
74
|
+
* um valor que começa com `-` é recusado, porque o parser o leria como opção;
|
|
75
|
+
* - opção de texto e `enum`: `--nome=valor`, uma forma só, que dispensa a separação por espaço e não
|
|
76
|
+
* deixa um valor que começa com `-` virar opção;
|
|
77
|
+
* - liga e desliga: `--nome` se verdadeira; se falsa, `--no-nome` quando o padrão dela é ligado (a
|
|
78
|
+
* `install` do `new`) e nada quando é desligado.
|
|
79
|
+
*
|
|
80
|
+
* Campo que o comando não tem, valor de outro tipo e posicional pulado são `UsageError`. O que falta
|
|
81
|
+
* de obrigatório e o valor fora da lista de um `enum` a conferência do `runCli` (`validateArgs`) acusa.
|
|
82
|
+
*/
|
|
83
|
+
export function toArgv(command, input) {
|
|
84
|
+
const known = new Set(command.options.map((option) => option.name));
|
|
85
|
+
for (const field of Object.keys(input)) {
|
|
86
|
+
if (!known.has(field)) {
|
|
87
|
+
throw new UsageError(`o comando '${command.name}' não tem o campo '${field}' (campos: ${[...known].join(', ') || 'nenhum'}).`);
|
|
88
|
+
}
|
|
89
|
+
}
|
|
90
|
+
const positionals = [];
|
|
91
|
+
const flags = [];
|
|
92
|
+
let skipped;
|
|
93
|
+
for (const option of command.options) {
|
|
94
|
+
const value = input[option.name];
|
|
95
|
+
if (option.kind === 'positional') {
|
|
96
|
+
if (value === undefined) {
|
|
97
|
+
skipped ??= option.name;
|
|
98
|
+
continue;
|
|
99
|
+
}
|
|
100
|
+
if (skipped !== undefined) {
|
|
101
|
+
throw new UsageError(`'${option.name}' foi dado sem '${skipped}', que vem antes dele.`);
|
|
102
|
+
}
|
|
103
|
+
let values;
|
|
104
|
+
if (option.variadic) {
|
|
105
|
+
if (!Array.isArray(value)) {
|
|
106
|
+
throw new UsageError(`'${option.name}' precisa ser uma lista de textos.`);
|
|
107
|
+
}
|
|
108
|
+
values = value.map((item) => textOf(item, option.name, 'uma lista de textos'));
|
|
109
|
+
}
|
|
110
|
+
else
|
|
111
|
+
values = [textOf(value, option.name, 'um texto')];
|
|
112
|
+
for (const item of values) {
|
|
113
|
+
if (item.startsWith('-')) {
|
|
114
|
+
throw new UsageError(`'${option.name}' não pode começar com '-' ('${item}'): o comando o leria como opção.`);
|
|
115
|
+
}
|
|
116
|
+
positionals.push(item);
|
|
117
|
+
}
|
|
118
|
+
continue;
|
|
119
|
+
}
|
|
120
|
+
if (value === undefined)
|
|
121
|
+
continue;
|
|
122
|
+
if (option.kind === 'boolean') {
|
|
123
|
+
if (typeof value !== 'boolean')
|
|
124
|
+
throw new UsageError(`'${option.name}' precisa ser verdadeiro ou falso.`);
|
|
125
|
+
if (value)
|
|
126
|
+
flags.push(`--${option.name}`);
|
|
127
|
+
else if (option.default === true)
|
|
128
|
+
flags.push(`--no-${option.name}`);
|
|
129
|
+
continue;
|
|
130
|
+
}
|
|
131
|
+
flags.push(`--${option.name}=${textOf(value, option.name, 'um texto')}`);
|
|
132
|
+
}
|
|
133
|
+
return [...positionals, ...flags];
|
|
134
|
+
}
|
|
@@ -0,0 +1,35 @@
|
|
|
1
|
+
/** A versão mínima do Node que o Prumo exige (os comandos rodam `.ts` direto, com type stripping). */
|
|
2
|
+
export declare const MIN_NODE_MAJOR = 24;
|
|
3
|
+
export type Status = 'ok' | 'warn' | 'error';
|
|
4
|
+
/** Uma linha do relatório: o que foi conferido, o resultado e a explicação. */
|
|
5
|
+
export interface Finding {
|
|
6
|
+
status: Status;
|
|
7
|
+
label: string;
|
|
8
|
+
message: string;
|
|
9
|
+
}
|
|
10
|
+
/**
|
|
11
|
+
* O que o `doctor` pergunta ao sistema. O comando passa o Node e o disco de verdade; os testes
|
|
12
|
+
* passam valores prontos e um mapa de arquivos, e assim não dependem da máquina.
|
|
13
|
+
*/
|
|
14
|
+
export interface DoctorSystem {
|
|
15
|
+
/** A versão do Node que está rodando a CLI (`process.versions.node`). */
|
|
16
|
+
nodeVersion: string;
|
|
17
|
+
/** A versão desta CLI, do `package.json` dela. */
|
|
18
|
+
cliVersion: string;
|
|
19
|
+
/** A versão do pnpm instalado, ou `undefined` se o pnpm não existe. Não usa a rede. */
|
|
20
|
+
pnpmVersion: () => string | undefined;
|
|
21
|
+
/** O conteúdo do arquivo, ou `undefined` se ele não existe ou não pode ser lido. */
|
|
22
|
+
readText: (file: string) => string | undefined;
|
|
23
|
+
/** O valor da variável de ambiente, ou `undefined` se ela não existe ou está vazia. */
|
|
24
|
+
env: (name: string) => string | undefined;
|
|
25
|
+
}
|
|
26
|
+
export interface DoctorInput {
|
|
27
|
+
root: string;
|
|
28
|
+
system: DoctorSystem;
|
|
29
|
+
}
|
|
30
|
+
/** Roda todas as conferências e devolve as linhas, na ordem do relatório. Não escreve nada. */
|
|
31
|
+
export declare function runChecks(input: DoctorInput): Finding[];
|
|
32
|
+
/** O nome do servidor do Prumo no `mcpServers` do `.mcp.json` (o `prumo new` o cria com ele). */
|
|
33
|
+
export declare const PRUMO_MCP_SERVER = "prumo";
|
|
34
|
+
/** O registry do GitHub Packages, onde os pacotes @matizze/prumo-* ficaram numa etapa provisória. */
|
|
35
|
+
export declare const GITHUB_PACKAGES_HOST = "npm.pkg.github.com";
|
|
@@ -0,0 +1,283 @@
|
|
|
1
|
+
import path from 'node:path';
|
|
2
|
+
import { CLI_PACKAGE_NAME, PRUMO_PACKAGES, PRUMO_PACKAGE_RANGES } from "./ranges.js";
|
|
3
|
+
import { caretRange, compareVersions, formatRange, formatVersion, parseRange, parseVersion, positionIn, } from "./versions.js";
|
|
4
|
+
/** A versão mínima do Node que o Prumo exige (os comandos rodam `.ts` direto, com type stripping). */
|
|
5
|
+
export const MIN_NODE_MAJOR = 24;
|
|
6
|
+
/** Roda todas as conferências e devolve as linhas, na ordem do relatório. Não escreve nada. */
|
|
7
|
+
export function runChecks(input) {
|
|
8
|
+
const manifest = readJson(input.system, path.join(input.root, 'package.json')) ?? {};
|
|
9
|
+
return [
|
|
10
|
+
checkNode(input, manifest),
|
|
11
|
+
checkPnpm(input, manifest),
|
|
12
|
+
...checkPackages(input, manifest),
|
|
13
|
+
checkMcpJson(input),
|
|
14
|
+
...checkRegistryToken(input),
|
|
15
|
+
];
|
|
16
|
+
}
|
|
17
|
+
function readJson(system, file) {
|
|
18
|
+
const text = system.readText(file);
|
|
19
|
+
if (text === undefined)
|
|
20
|
+
return undefined;
|
|
21
|
+
try {
|
|
22
|
+
const value = JSON.parse(text);
|
|
23
|
+
return typeof value === 'object' && value !== null && !Array.isArray(value)
|
|
24
|
+
? value
|
|
25
|
+
: undefined;
|
|
26
|
+
}
|
|
27
|
+
catch {
|
|
28
|
+
return undefined;
|
|
29
|
+
}
|
|
30
|
+
}
|
|
31
|
+
/** Procura o arquivo na pasta do projeto e, se não achar, nas pastas acima (um monorepo guarda o `.nvmrc` na raiz). */
|
|
32
|
+
function readUp(system, from, name) {
|
|
33
|
+
for (let dir = from;; dir = path.dirname(dir)) {
|
|
34
|
+
const text = system.readText(path.join(dir, name));
|
|
35
|
+
if (text !== undefined)
|
|
36
|
+
return text;
|
|
37
|
+
if (path.dirname(dir) === dir)
|
|
38
|
+
return undefined;
|
|
39
|
+
}
|
|
40
|
+
}
|
|
41
|
+
function asString(value) {
|
|
42
|
+
return typeof value === 'string' ? value : undefined;
|
|
43
|
+
}
|
|
44
|
+
// Node
|
|
45
|
+
function checkNode({ root, system }, manifest) {
|
|
46
|
+
const label = 'Node';
|
|
47
|
+
const running = parseVersion(system.nodeVersion);
|
|
48
|
+
if (!running) {
|
|
49
|
+
return { status: 'error', label, message: `não entendi a versão '${system.nodeVersion}'.` };
|
|
50
|
+
}
|
|
51
|
+
const shown = formatVersion(running);
|
|
52
|
+
if (running.major < MIN_NODE_MAJOR) {
|
|
53
|
+
return {
|
|
54
|
+
status: 'error',
|
|
55
|
+
label,
|
|
56
|
+
message: `${shown} é antiga: o Prumo exige Node >= ${MIN_NODE_MAJOR}. Instale o Node ${MIN_NODE_MAJOR} (nvm install ${MIN_NODE_MAJOR}).`,
|
|
57
|
+
};
|
|
58
|
+
}
|
|
59
|
+
const notes = [`mínimo do Prumo: ${MIN_NODE_MAJOR}`];
|
|
60
|
+
const warnings = [];
|
|
61
|
+
const nvmrc = readUp(system, root, '.nvmrc')?.trim();
|
|
62
|
+
if (nvmrc !== undefined) {
|
|
63
|
+
const wanted = parseVersion(nvmrc);
|
|
64
|
+
if (!wanted) {
|
|
65
|
+
warnings.push(`não entendi o .nvmrc ('${nvmrc}')`);
|
|
66
|
+
}
|
|
67
|
+
else if (nvmrc.split('.').length === 1 ? running.major !== wanted.major : !isSameLine(running, wanted)) {
|
|
68
|
+
warnings.push(`o .nvmrc pede ${nvmrc}: rode nvm use`);
|
|
69
|
+
}
|
|
70
|
+
else {
|
|
71
|
+
notes.push(`.nvmrc: ${nvmrc}`);
|
|
72
|
+
}
|
|
73
|
+
}
|
|
74
|
+
const engines = manifest.engines;
|
|
75
|
+
const enginesNode = typeof engines === 'object' && engines !== null ? asString(engines.node) : undefined;
|
|
76
|
+
const enginesMin = enginesNode ? /^>=\s*(\S+)$/.exec(enginesNode.trim())?.[1] : undefined;
|
|
77
|
+
const enginesVersion = enginesMin ? parseVersion(enginesMin) : undefined;
|
|
78
|
+
if (enginesVersion) {
|
|
79
|
+
if (compareVersions(running, enginesVersion) < 0) {
|
|
80
|
+
warnings.push(`o engines do package.json pede ${enginesNode}`);
|
|
81
|
+
}
|
|
82
|
+
else {
|
|
83
|
+
notes.push(`engines: ${enginesNode}`);
|
|
84
|
+
}
|
|
85
|
+
}
|
|
86
|
+
if (warnings.length > 0) {
|
|
87
|
+
return { status: 'warn', label, message: `${shown}: ${warnings.join('; ')}.` };
|
|
88
|
+
}
|
|
89
|
+
return { status: 'ok', label, message: `${shown} (${notes.join('; ')}).` };
|
|
90
|
+
}
|
|
91
|
+
/** Mesma major e, no `.nvmrc` com minor ou patch, nunca abaixo do que ele pede. */
|
|
92
|
+
function isSameLine(running, wanted) {
|
|
93
|
+
return running.major === wanted.major && compareVersions(running, wanted) >= 0;
|
|
94
|
+
}
|
|
95
|
+
// pnpm
|
|
96
|
+
function checkPnpm({ root, system }, manifest) {
|
|
97
|
+
const label = 'pnpm';
|
|
98
|
+
const installedText = system.pnpmVersion();
|
|
99
|
+
if (installedText === undefined) {
|
|
100
|
+
return {
|
|
101
|
+
status: 'error',
|
|
102
|
+
label,
|
|
103
|
+
message: 'o pnpm não foi encontrado. Instale com "corepack enable" ou "npm install -g pnpm".',
|
|
104
|
+
};
|
|
105
|
+
}
|
|
106
|
+
const installed = parseVersion(installedText);
|
|
107
|
+
if (!installed) {
|
|
108
|
+
return { status: 'warn', label, message: `não entendi a versão '${installedText}'.` };
|
|
109
|
+
}
|
|
110
|
+
const shown = formatVersion(installed);
|
|
111
|
+
const declared = asString(manifest.packageManager) ?? packageManagerUp(system, root);
|
|
112
|
+
if (declared === undefined) {
|
|
113
|
+
return {
|
|
114
|
+
status: 'warn',
|
|
115
|
+
label,
|
|
116
|
+
message: `${shown}, mas o package.json não tem packageManager: fixe a versão com "pnpm@${shown}".`,
|
|
117
|
+
};
|
|
118
|
+
}
|
|
119
|
+
const [name, spec = ''] = declared.split('@');
|
|
120
|
+
const wanted = parseVersion(spec);
|
|
121
|
+
if (name !== 'pnpm' || !wanted) {
|
|
122
|
+
return {
|
|
123
|
+
status: 'warn',
|
|
124
|
+
label,
|
|
125
|
+
message: `${shown}, mas o packageManager é '${declared}': o Prumo usa o pnpm.`,
|
|
126
|
+
};
|
|
127
|
+
}
|
|
128
|
+
if (installed.major !== wanted.major || compareVersions(installed, wanted) < 0) {
|
|
129
|
+
return {
|
|
130
|
+
status: 'warn',
|
|
131
|
+
label,
|
|
132
|
+
message: `${shown}, mas o packageManager pede ${declared}: rode "corepack use ${declared}" ou instale essa versão.`,
|
|
133
|
+
};
|
|
134
|
+
}
|
|
135
|
+
return { status: 'ok', label, message: `${shown} (packageManager: ${declared}).` };
|
|
136
|
+
}
|
|
137
|
+
/** O `packageManager` de um monorepo fica no `package.json` da raiz, acima do projeto. */
|
|
138
|
+
function packageManagerUp(system, root) {
|
|
139
|
+
for (let dir = path.dirname(root);; dir = path.dirname(dir)) {
|
|
140
|
+
const value = asString(readJson(system, path.join(dir, 'package.json'))?.packageManager);
|
|
141
|
+
if (value !== undefined)
|
|
142
|
+
return value;
|
|
143
|
+
if (path.dirname(dir) === dir)
|
|
144
|
+
return undefined;
|
|
145
|
+
}
|
|
146
|
+
}
|
|
147
|
+
// Pacotes do Prumo
|
|
148
|
+
function declaredDependencies(manifest) {
|
|
149
|
+
const names = new Set();
|
|
150
|
+
for (const field of ['dependencies', 'devDependencies', 'peerDependencies']) {
|
|
151
|
+
const value = manifest[field];
|
|
152
|
+
if (typeof value === 'object' && value !== null) {
|
|
153
|
+
for (const name of Object.keys(value))
|
|
154
|
+
names.add(name);
|
|
155
|
+
}
|
|
156
|
+
}
|
|
157
|
+
return names;
|
|
158
|
+
}
|
|
159
|
+
function expectedRange({ system }, name) {
|
|
160
|
+
if (name === CLI_PACKAGE_NAME) {
|
|
161
|
+
const own = parseVersion(system.cliVersion);
|
|
162
|
+
return own ? caretRange(own) : undefined;
|
|
163
|
+
}
|
|
164
|
+
const text = PRUMO_PACKAGE_RANGES[name];
|
|
165
|
+
return text ? parseRange(text) : undefined;
|
|
166
|
+
}
|
|
167
|
+
function checkPackages(input, manifest) {
|
|
168
|
+
const declared = declaredDependencies(manifest);
|
|
169
|
+
const findings = [];
|
|
170
|
+
for (const name of PRUMO_PACKAGES) {
|
|
171
|
+
const installedManifest = readJson(input.system, path.join(input.root, 'node_modules', name, 'package.json'));
|
|
172
|
+
if (!installedManifest) {
|
|
173
|
+
if (declared.has(name)) {
|
|
174
|
+
findings.push({
|
|
175
|
+
status: 'error',
|
|
176
|
+
label: name,
|
|
177
|
+
message: 'está no package.json, mas não está instalado: rode "pnpm install".',
|
|
178
|
+
});
|
|
179
|
+
}
|
|
180
|
+
continue;
|
|
181
|
+
}
|
|
182
|
+
findings.push(checkPackage(input, name, asString(installedManifest.version)));
|
|
183
|
+
}
|
|
184
|
+
if (findings.length === 0) {
|
|
185
|
+
findings.push({
|
|
186
|
+
status: 'warn',
|
|
187
|
+
label: 'Pacotes do Prumo',
|
|
188
|
+
message: 'nenhum pacote @matizze/prumo-* neste projeto.',
|
|
189
|
+
});
|
|
190
|
+
}
|
|
191
|
+
return findings;
|
|
192
|
+
}
|
|
193
|
+
function checkPackage(input, name, versionText) {
|
|
194
|
+
const version = versionText ? parseVersion(versionText) : undefined;
|
|
195
|
+
if (!version) {
|
|
196
|
+
return { status: 'warn', label: name, message: `não entendi a versão '${versionText ?? ''}'.` };
|
|
197
|
+
}
|
|
198
|
+
const shown = formatVersion(version);
|
|
199
|
+
const range = expectedRange(input, name);
|
|
200
|
+
if (!range)
|
|
201
|
+
return { status: 'ok', label: name, message: `${shown}.` };
|
|
202
|
+
const position = positionIn(version, range);
|
|
203
|
+
const expected = formatRange(range);
|
|
204
|
+
if (position === 'behind') {
|
|
205
|
+
return {
|
|
206
|
+
status: 'warn',
|
|
207
|
+
label: name,
|
|
208
|
+
message: `${shown} está atrás da faixa que esta CLI espera (${expected}): atualize o pacote.`,
|
|
209
|
+
};
|
|
210
|
+
}
|
|
211
|
+
if (position === 'ahead') {
|
|
212
|
+
return {
|
|
213
|
+
status: 'warn',
|
|
214
|
+
label: name,
|
|
215
|
+
message: `${shown} está à frente da faixa que esta CLI espera (${expected}): atualize a CLI (${CLI_PACKAGE_NAME}).`,
|
|
216
|
+
};
|
|
217
|
+
}
|
|
218
|
+
return { status: 'ok', label: name, message: `${shown} (esperado: ${expected}).` };
|
|
219
|
+
}
|
|
220
|
+
// .mcp.json
|
|
221
|
+
/** O nome do servidor do Prumo no `mcpServers` do `.mcp.json` (o `prumo new` o cria com ele). */
|
|
222
|
+
export const PRUMO_MCP_SERVER = 'prumo';
|
|
223
|
+
/**
|
|
224
|
+
* O `.mcp.json`: existe, é um JSON de objeto e tem o servidor `prumo` (o `prumo-mcp`, com que o agente
|
|
225
|
+
* faz pelo MCP o que a pessoa faz pela CLI). Sem ele, aviso: o projeto funciona, só o agente não
|
|
226
|
+
* enxerga as ferramentas do Prumo.
|
|
227
|
+
*/
|
|
228
|
+
function checkMcpJson({ root, system }) {
|
|
229
|
+
const label = '.mcp.json';
|
|
230
|
+
const file = path.join(root, label);
|
|
231
|
+
if (system.readText(file) === undefined) {
|
|
232
|
+
return {
|
|
233
|
+
status: 'warn',
|
|
234
|
+
label,
|
|
235
|
+
message: 'não existe (a configuração dos servidores MCP, entre eles o do prumo).',
|
|
236
|
+
};
|
|
237
|
+
}
|
|
238
|
+
const manifest = readJson(system, file);
|
|
239
|
+
if (!manifest)
|
|
240
|
+
return { status: 'warn', label, message: 'não é um JSON de objeto válido.' };
|
|
241
|
+
const servers = manifest.mcpServers;
|
|
242
|
+
const server = typeof servers === 'object' && servers !== null
|
|
243
|
+
? servers[PRUMO_MCP_SERVER]
|
|
244
|
+
: undefined;
|
|
245
|
+
const command = typeof server === 'object' && server !== null
|
|
246
|
+
? server.command
|
|
247
|
+
: undefined;
|
|
248
|
+
if (typeof command !== 'string' || command === '') {
|
|
249
|
+
return {
|
|
250
|
+
status: 'warn',
|
|
251
|
+
label,
|
|
252
|
+
message: `sem o servidor ${PRUMO_MCP_SERVER} (com "command") em "mcpServers": o agente não vê as ferramentas do Prumo. Acrescente "${PRUMO_MCP_SERVER}": { "command": "pnpm", "args": ["exec", "prumo-mcp"] } e o @matizze/prumo-mcp como devDependency.`,
|
|
253
|
+
};
|
|
254
|
+
}
|
|
255
|
+
return { status: 'ok', label, message: `existe, com o servidor ${PRUMO_MCP_SERVER}.` };
|
|
256
|
+
}
|
|
257
|
+
// .npmrc
|
|
258
|
+
/** O registry do GitHub Packages, onde os pacotes @matizze/prumo-* ficaram numa etapa provisória. */
|
|
259
|
+
export const GITHUB_PACKAGES_HOST = 'npm.pkg.github.com';
|
|
260
|
+
/** O `.npmrc` manda o escopo `@matizze` para o GitHub Packages? (`@matizze:registry=https://npm.pkg.github.com`) */
|
|
261
|
+
function routesScopeToGithubPackages(npmrc) {
|
|
262
|
+
return npmrc.split('\n').some((raw) => {
|
|
263
|
+
const match = /^\s*@matizze:registry\s*=\s*(\S+)\s*$/.exec(raw);
|
|
264
|
+
return match?.[1] !== undefined && match[1].includes(GITHUB_PACKAGES_HOST);
|
|
265
|
+
});
|
|
266
|
+
}
|
|
267
|
+
/**
|
|
268
|
+
* O `.npmrc` antigo: os pacotes do Prumo agora estão no npm público, então a linha que manda o escopo
|
|
269
|
+
* `@matizze` para o GitHub Packages pode sair. Sem `.npmrc` desse tipo, não há linha. Não lê nem mostra
|
|
270
|
+
* token nenhum.
|
|
271
|
+
*/
|
|
272
|
+
function checkRegistryToken({ root, system }) {
|
|
273
|
+
const npmrc = system.readText(path.join(root, '.npmrc'));
|
|
274
|
+
if (npmrc === undefined || !routesScopeToGithubPackages(npmrc))
|
|
275
|
+
return [];
|
|
276
|
+
return [
|
|
277
|
+
{
|
|
278
|
+
status: 'warn',
|
|
279
|
+
label: '.npmrc',
|
|
280
|
+
message: `o escopo @matizze aponta para o GitHub Packages (${GITHUB_PACKAGES_HOST}), mas os pacotes do Prumo agora estão no npm público: a linha pode sair do .npmrc, e o token também.`,
|
|
281
|
+
},
|
|
282
|
+
];
|
|
283
|
+
}
|
|
@@ -0,0 +1,16 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* As faixas de versão dos pacotes do Prumo que esta CLI espera num projeto, para o `prumo doctor`.
|
|
3
|
+
*
|
|
4
|
+
* Os pacotes versionam separados (o cli está na 0.5.0, o core na 0.1.3), então a comparação é por
|
|
5
|
+
* faixa compatível, não por igualdade: `>=mínimo <limite`. O Changesets não mantém um campo
|
|
6
|
+
* próprio do `package.json` (ele só atualiza `dependencies`, `devDependencies` e
|
|
7
|
+
* `peerDependencies`, e o cli não depende do core nem do testing), então a tabela mora aqui e o
|
|
8
|
+
* `ranges.test.ts` a compara com o `package.json` de cada pacote do workspace: quando um pacote
|
|
9
|
+
* sai da faixa (uma versão que quebra a compatibilidade), o teste falha e a faixa é revista junto.
|
|
10
|
+
*
|
|
11
|
+
* A faixa do próprio `@matizze/prumo-cli` não está na tabela: é a da versão que está rodando.
|
|
12
|
+
*/
|
|
13
|
+
export declare const PRUMO_PACKAGE_RANGES: Readonly<Record<string, string>>;
|
|
14
|
+
export declare const CLI_PACKAGE_NAME = "@matizze/prumo-cli";
|
|
15
|
+
/** Os pacotes do Prumo que o `doctor` confere, na ordem em que aparecem. */
|
|
16
|
+
export declare const PRUMO_PACKAGES: readonly string[];
|
|
@@ -0,0 +1,27 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* As faixas de versão dos pacotes do Prumo que esta CLI espera num projeto, para o `prumo doctor`.
|
|
3
|
+
*
|
|
4
|
+
* Os pacotes versionam separados (o cli está na 0.5.0, o core na 0.1.3), então a comparação é por
|
|
5
|
+
* faixa compatível, não por igualdade: `>=mínimo <limite`. O Changesets não mantém um campo
|
|
6
|
+
* próprio do `package.json` (ele só atualiza `dependencies`, `devDependencies` e
|
|
7
|
+
* `peerDependencies`, e o cli não depende do core nem do testing), então a tabela mora aqui e o
|
|
8
|
+
* `ranges.test.ts` a compara com o `package.json` de cada pacote do workspace: quando um pacote
|
|
9
|
+
* sai da faixa (uma versão que quebra a compatibilidade), o teste falha e a faixa é revista junto.
|
|
10
|
+
*
|
|
11
|
+
* A faixa do próprio `@matizze/prumo-cli` não está na tabela: é a da versão que está rodando.
|
|
12
|
+
*/
|
|
13
|
+
export const PRUMO_PACKAGE_RANGES = {
|
|
14
|
+
'@matizze/prumo-core': '>=0.1.0 <0.2.0',
|
|
15
|
+
'@matizze/prumo-rules': '>=0.2.0 <0.3.0',
|
|
16
|
+
'@matizze/prumo-testing': '>=0.2.0 <0.3.0',
|
|
17
|
+
'@matizze/prumo-mcp': '>=0.1.0 <0.2.0',
|
|
18
|
+
};
|
|
19
|
+
export const CLI_PACKAGE_NAME = '@matizze/prumo-cli';
|
|
20
|
+
/** Os pacotes do Prumo que o `doctor` confere, na ordem em que aparecem. */
|
|
21
|
+
export const PRUMO_PACKAGES = [
|
|
22
|
+
'@matizze/prumo-core',
|
|
23
|
+
'@matizze/prumo-rules',
|
|
24
|
+
'@matizze/prumo-testing',
|
|
25
|
+
'@matizze/prumo-mcp',
|
|
26
|
+
CLI_PACKAGE_NAME,
|
|
27
|
+
];
|