@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,33 @@
|
|
|
1
|
+
import type { Runtime } from '../runtime.js';
|
|
2
|
+
/**
|
|
3
|
+
* `prumo make:component <nome> --page <tela>` ou `--shared`: gera um componente (só HTML) e o teste
|
|
4
|
+
* dele a partir dos modelos do pacote, em `src/pages/<tela>/components/` ou em
|
|
5
|
+
* `src/components/shared/`. Valida tudo antes de escrever e aceita `--dry-run`. Ao terminar, roda o
|
|
6
|
+
* `prumo check`; o componente `--shared` ainda sem uso em duas telas aparece como esperado, e não
|
|
7
|
+
* faz o comando falhar.
|
|
8
|
+
*/
|
|
9
|
+
export declare function createMakeComponentCommand(runtime: Runtime): import("citty").CommandDef<{
|
|
10
|
+
readonly nome: {
|
|
11
|
+
readonly type: "positional";
|
|
12
|
+
readonly required: true;
|
|
13
|
+
readonly description: "Nome do componente, em kebab-case (por exemplo, resumo-do-pedido).";
|
|
14
|
+
};
|
|
15
|
+
readonly page: {
|
|
16
|
+
readonly type: "string";
|
|
17
|
+
readonly valueHint: "tela";
|
|
18
|
+
readonly description: "A tela dona do componente (src/pages/<tela>/components/).";
|
|
19
|
+
};
|
|
20
|
+
readonly shared: {
|
|
21
|
+
readonly type: "boolean";
|
|
22
|
+
readonly description: "O componente é de uso comum (src/components/shared/).";
|
|
23
|
+
};
|
|
24
|
+
readonly root: {
|
|
25
|
+
readonly type: "string";
|
|
26
|
+
readonly valueHint: "pasta";
|
|
27
|
+
readonly description: "Pasta do projeto, a que tem o src. Padrão: a pasta atual.";
|
|
28
|
+
};
|
|
29
|
+
readonly 'dry-run': {
|
|
30
|
+
readonly type: "boolean";
|
|
31
|
+
readonly description: "Só lista o que seria criado, sem escrever nada.";
|
|
32
|
+
};
|
|
33
|
+
}>;
|
|
@@ -0,0 +1,85 @@
|
|
|
1
|
+
import { defineCommand } from 'citty';
|
|
2
|
+
import path from 'node:path';
|
|
3
|
+
import { generateComponent } from "../generate/component.js";
|
|
4
|
+
import { findProject } from "../project.js";
|
|
5
|
+
import { finishWithCheck, formatSummary, testCommandFor } from "./shared.js";
|
|
6
|
+
/**
|
|
7
|
+
* `prumo make:component <nome> --page <tela>` ou `--shared`: gera um componente (só HTML) e o teste
|
|
8
|
+
* dele a partir dos modelos do pacote, em `src/pages/<tela>/components/` ou em
|
|
9
|
+
* `src/components/shared/`. Valida tudo antes de escrever e aceita `--dry-run`. Ao terminar, roda o
|
|
10
|
+
* `prumo check`; o componente `--shared` ainda sem uso em duas telas aparece como esperado, e não
|
|
11
|
+
* faz o comando falhar.
|
|
12
|
+
*/
|
|
13
|
+
export function createMakeComponentCommand(runtime) {
|
|
14
|
+
return defineCommand({
|
|
15
|
+
meta: {
|
|
16
|
+
name: 'make:component',
|
|
17
|
+
description: `Gera um componente novo, só com elementos HTML, e o teste dele.
|
|
18
|
+
|
|
19
|
+
Com --page <tela>, o componente é da tela e vai para src/pages/<tela>/components/ (a tela precisa
|
|
20
|
+
existir, crie-a com make:page). Com --shared, vai para src/components/shared/, que é o lugar do que
|
|
21
|
+
duas ou mais telas usam. Use um dos dois.
|
|
22
|
+
|
|
23
|
+
O nome é o do componente, em kebab-case (resumo-do-pedido): o arquivo é <nome>.tsx e o componente
|
|
24
|
+
exportado, em PascalCase. O prumo check cobra que o que está em shared seja usado por 2 ou mais
|
|
25
|
+
telas; um componente shared recém-gerado ainda não é, e o comando avisa isso sem falhar.
|
|
26
|
+
|
|
27
|
+
Valida tudo antes de escrever e recusa sobrescrever. Sai com código 1 se o check achar outra
|
|
28
|
+
violação (o componente já foi gerado) e com 2 se o uso está errado: nome inválido ou reservado,
|
|
29
|
+
nem --page nem --shared (ou os dois), tela que não existe, componente que já existe.`,
|
|
30
|
+
},
|
|
31
|
+
args: {
|
|
32
|
+
nome: {
|
|
33
|
+
type: 'positional',
|
|
34
|
+
required: true,
|
|
35
|
+
description: 'Nome do componente, em kebab-case (por exemplo, resumo-do-pedido).',
|
|
36
|
+
},
|
|
37
|
+
page: {
|
|
38
|
+
type: 'string',
|
|
39
|
+
valueHint: 'tela',
|
|
40
|
+
description: 'A tela dona do componente (src/pages/<tela>/components/).',
|
|
41
|
+
},
|
|
42
|
+
shared: {
|
|
43
|
+
type: 'boolean',
|
|
44
|
+
description: 'O componente é de uso comum (src/components/shared/).',
|
|
45
|
+
},
|
|
46
|
+
root: {
|
|
47
|
+
type: 'string',
|
|
48
|
+
valueHint: 'pasta',
|
|
49
|
+
description: 'Pasta do projeto, a que tem o src. Padrão: a pasta atual.',
|
|
50
|
+
},
|
|
51
|
+
'dry-run': {
|
|
52
|
+
type: 'boolean',
|
|
53
|
+
description: 'Só lista o que seria criado, sem escrever nada.',
|
|
54
|
+
},
|
|
55
|
+
},
|
|
56
|
+
run({ args }) {
|
|
57
|
+
const project = findProject(path.resolve(runtime.cwd, args.root ?? '.'));
|
|
58
|
+
const { plan, names, folder, file, page } = generateComponent(project, {
|
|
59
|
+
name: args.nome,
|
|
60
|
+
page: args.page,
|
|
61
|
+
shared: args.shared,
|
|
62
|
+
});
|
|
63
|
+
const heading = `prumo make:component: ${names.kebab} (${folder}).`;
|
|
64
|
+
if (args['dry-run']) {
|
|
65
|
+
runtime.out(`${heading}\n\n${formatSummary(plan.summary(), true)}\nSimulação (--dry-run): nada foi escrito.\n`);
|
|
66
|
+
return;
|
|
67
|
+
}
|
|
68
|
+
const summary = plan.commit();
|
|
69
|
+
runtime.out(`${heading}\n\n${formatSummary(summary, false)}\n`);
|
|
70
|
+
const use = page
|
|
71
|
+
? `Use-o na view da tela: import { ${names.pascal} } from './components/${names.kebab}'.`
|
|
72
|
+
: `Importe-o nas telas que o usam: import { ${names.pascal} } from '@/components/shared/${names.kebab}'.`;
|
|
73
|
+
const next = `Edite o componente (${file}); o teste acompanha. ${use}\n\nPara rodar os testes do componente novo:\n ${testCommandFor(project, runtime.cwd, folder)}\n`;
|
|
74
|
+
finishWithCheck(runtime, project, {
|
|
75
|
+
generated: 'o componente foi gerado',
|
|
76
|
+
next,
|
|
77
|
+
expected: {
|
|
78
|
+
matches: (violation) => violation.rule === 'shared-usage' && violation.file === file,
|
|
79
|
+
intro: 'só a violação esperada de um componente shared ainda sem uso:',
|
|
80
|
+
note: 'Ela some quando duas telas importarem o componente.',
|
|
81
|
+
},
|
|
82
|
+
});
|
|
83
|
+
},
|
|
84
|
+
});
|
|
85
|
+
}
|
|
@@ -0,0 +1,30 @@
|
|
|
1
|
+
import type { Runtime } from '../runtime.js';
|
|
2
|
+
/**
|
|
3
|
+
* `prumo make:domain <nome> [--entity <singular>]`: gera um domínio de dados a partir dos modelos
|
|
4
|
+
* do pacote (nunca copiando outro domínio do projeto): o schema da entidade, o repositório
|
|
5
|
+
* (contrato, mock com fixtures e latência, index e teste de contrato) e as queries com os hooks, e
|
|
6
|
+
* registra o domínio nos três índices e no container. Valida tudo antes de escrever, então um erro
|
|
7
|
+
* de uso (saída 2) não deixa o projeto pela metade, e `--dry-run` só lista o que seria feito. Ao
|
|
8
|
+
* terminar, roda o `prumo check`; com violação sai com 1, já com o domínio gerado.
|
|
9
|
+
*/
|
|
10
|
+
export declare function createMakeDomainCommand(runtime: Runtime): import("citty").CommandDef<{
|
|
11
|
+
readonly nome: {
|
|
12
|
+
readonly type: "positional";
|
|
13
|
+
readonly required: true;
|
|
14
|
+
readonly description: "Nome do domínio, no plural e em kebab-case (por exemplo, clientes).";
|
|
15
|
+
};
|
|
16
|
+
readonly entity: {
|
|
17
|
+
readonly type: "string";
|
|
18
|
+
readonly valueHint: "singular";
|
|
19
|
+
readonly description: "A entidade, no singular (por exemplo, cliente). Padrão: o nome sem o s final.";
|
|
20
|
+
};
|
|
21
|
+
readonly root: {
|
|
22
|
+
readonly type: "string";
|
|
23
|
+
readonly valueHint: "pasta";
|
|
24
|
+
readonly description: "Pasta do projeto, a que tem o src. Padrão: a pasta atual.";
|
|
25
|
+
};
|
|
26
|
+
readonly 'dry-run': {
|
|
27
|
+
readonly type: "boolean";
|
|
28
|
+
readonly description: "Só lista o que seria criado e alterado, sem escrever nada.";
|
|
29
|
+
};
|
|
30
|
+
}>;
|
|
@@ -0,0 +1,83 @@
|
|
|
1
|
+
import { defineCommand } from 'citty';
|
|
2
|
+
import { existsSync } from 'node:fs';
|
|
3
|
+
import path from 'node:path';
|
|
4
|
+
import { generateDomain } from "../generate/domain.js";
|
|
5
|
+
import { findProject } from "../project.js";
|
|
6
|
+
import { finishWithCheck, formatSummary, testCommandFor } from "./shared.js";
|
|
7
|
+
/**
|
|
8
|
+
* `prumo make:domain <nome> [--entity <singular>]`: gera um domínio de dados a partir dos modelos
|
|
9
|
+
* do pacote (nunca copiando outro domínio do projeto): o schema da entidade, o repositório
|
|
10
|
+
* (contrato, mock com fixtures e latência, index e teste de contrato) e as queries com os hooks, e
|
|
11
|
+
* registra o domínio nos três índices e no container. Valida tudo antes de escrever, então um erro
|
|
12
|
+
* de uso (saída 2) não deixa o projeto pela metade, e `--dry-run` só lista o que seria feito. Ao
|
|
13
|
+
* terminar, roda o `prumo check`; com violação sai com 1, já com o domínio gerado.
|
|
14
|
+
*/
|
|
15
|
+
export function createMakeDomainCommand(runtime) {
|
|
16
|
+
return defineCommand({
|
|
17
|
+
meta: {
|
|
18
|
+
name: 'make:domain',
|
|
19
|
+
description: `Gera um domínio de dados novo: schema, repositório com mock, queries e teste de contrato.
|
|
20
|
+
|
|
21
|
+
Cria o schema da entidade (src/schemas/entities/<entidade>.ts, com zod: id, name e createdAt), o
|
|
22
|
+
repositório (src/repositories/<nome>/: contrato, mock com fixtures e a latência simulada do core,
|
|
23
|
+
index e o teste de contrato do @matizze/prumo-testing) e as queries (src/queries/<nome>.ts: query
|
|
24
|
+
keys do core, as queries e os hooks de lista, detalhe e mutations do TanStack Query). Registra o
|
|
25
|
+
domínio em src/schemas/index.ts, src/repositories/index.ts (o import, o export * e a entrada no
|
|
26
|
+
mapa factories, que é o container, em ordem alfabética) e src/queries/index.ts. O tipo do container
|
|
27
|
+
acompanha o mapa sozinho.
|
|
28
|
+
|
|
29
|
+
O nome é o do domínio, no plural e em kebab-case (clientes, pedidos-recentes). A entidade é o
|
|
30
|
+
singular, que sai do nome (tira o s final). Onde a regra erra (o plural termina em ies, us, ss, xes,
|
|
31
|
+
ches, shes ou sses), o comando recusa e pede a entidade com --entity: categories daria categorie, e
|
|
32
|
+
o certo é --entity category.
|
|
33
|
+
|
|
34
|
+
Os hooks pegam o repositório de useRepositories(), de src/providers/repository, e o teste de
|
|
35
|
+
contrato é o que o mock cumpre: edite o schema e as fixtures depois, e o contrato junto.
|
|
36
|
+
|
|
37
|
+
Valida tudo antes de escrever e recusa sobrescrever. Ao terminar, roda o prumo check e mostra o
|
|
38
|
+
comando dos testes do domínio novo. Sai com código 1 se o check achar violação (o domínio já foi
|
|
39
|
+
gerado) e com 2 se o uso está errado: nome inválido ou reservado, singular suspeito, domínio que
|
|
40
|
+
já existe, índice que falta.`,
|
|
41
|
+
},
|
|
42
|
+
args: {
|
|
43
|
+
nome: {
|
|
44
|
+
type: 'positional',
|
|
45
|
+
required: true,
|
|
46
|
+
description: 'Nome do domínio, no plural e em kebab-case (por exemplo, clientes).',
|
|
47
|
+
},
|
|
48
|
+
entity: {
|
|
49
|
+
type: 'string',
|
|
50
|
+
valueHint: 'singular',
|
|
51
|
+
description: 'A entidade, no singular (por exemplo, cliente). Padrão: o nome sem o s final.',
|
|
52
|
+
},
|
|
53
|
+
root: {
|
|
54
|
+
type: 'string',
|
|
55
|
+
valueHint: 'pasta',
|
|
56
|
+
description: 'Pasta do projeto, a que tem o src. Padrão: a pasta atual.',
|
|
57
|
+
},
|
|
58
|
+
'dry-run': {
|
|
59
|
+
type: 'boolean',
|
|
60
|
+
description: 'Só lista o que seria criado e alterado, sem escrever nada.',
|
|
61
|
+
},
|
|
62
|
+
},
|
|
63
|
+
run({ args }) {
|
|
64
|
+
const project = findProject(path.resolve(runtime.cwd, args.root ?? '.'));
|
|
65
|
+
const { plan, names } = generateDomain(project, { name: args.nome, entity: args.entity });
|
|
66
|
+
const heading = `prumo make:domain: ${names.plural.kebab} (entidade ${names.singular.kebab}).`;
|
|
67
|
+
if (args['dry-run']) {
|
|
68
|
+
runtime.out(`${heading}\n\n${formatSummary(plan.summary(), true)}\nSimulação (--dry-run): nada foi escrito.\n`);
|
|
69
|
+
return;
|
|
70
|
+
}
|
|
71
|
+
const summary = plan.commit();
|
|
72
|
+
runtime.out(`${heading}\n\n${formatSummary(summary, false)}\n`);
|
|
73
|
+
const schema = `src/schemas/entities/${names.singular.kebab}.ts`;
|
|
74
|
+
const fixtures = `src/repositories/${names.plural.kebab}/fixtures.ts`;
|
|
75
|
+
const hasProvider = ['index.ts', 'index.tsx'].some((file) => existsSync(path.join(project.src, 'providers', 'repository', file)));
|
|
76
|
+
const provider = hasProvider
|
|
77
|
+
? ''
|
|
78
|
+
: `As queries importam useRepositories de @/providers/repository, e o projeto não tem src/providers/repository: crie-o com createRepositoryContext, de @matizze/prumo-core/repositories.\n`;
|
|
79
|
+
const next = `Edite o schema (${schema}) e as fixtures (${fixtures}); o teste de contrato acompanha.\n${provider}\nPara rodar os testes do domínio novo:\n ${testCommandFor(project, runtime.cwd, `src/repositories/${names.plural.kebab}`)}\n`;
|
|
80
|
+
finishWithCheck(runtime, project, { generated: 'o domínio foi gerado', next });
|
|
81
|
+
},
|
|
82
|
+
});
|
|
83
|
+
}
|
|
@@ -0,0 +1,30 @@
|
|
|
1
|
+
import type { Runtime } from '../runtime.js';
|
|
2
|
+
/**
|
|
3
|
+
* `prumo make:page <nome> [--domain <domínio>]`: gera uma tela a partir dos modelos do pacote
|
|
4
|
+
* (nunca copiando outra tela do projeto): `index`, `model`, `view` e o teste, as mensagens nos
|
|
5
|
+
* idiomas do projeto, o namespace nos índices de mensagens e a rota no `src/App.tsx`. Valida tudo
|
|
6
|
+
* antes de escrever, então um erro de uso (saída 2) não deixa o projeto pela metade, e `--dry-run`
|
|
7
|
+
* só lista o que seria feito. Ao terminar, roda o `prumo check`; com violação sai com 1, já com a
|
|
8
|
+
* tela gerada.
|
|
9
|
+
*/
|
|
10
|
+
export declare function createMakePageCommand(runtime: Runtime): import("citty").CommandDef<{
|
|
11
|
+
readonly nome: {
|
|
12
|
+
readonly type: "positional";
|
|
13
|
+
readonly required: true;
|
|
14
|
+
readonly description: "Nome da tela, em kebab-case (por exemplo, clientes).";
|
|
15
|
+
};
|
|
16
|
+
readonly domain: {
|
|
17
|
+
readonly type: "string";
|
|
18
|
+
readonly valueHint: "domínio";
|
|
19
|
+
readonly description: "Domínio cuja lista a tela mostra (por exemplo, clientes). Padrão: nenhum.";
|
|
20
|
+
};
|
|
21
|
+
readonly root: {
|
|
22
|
+
readonly type: "string";
|
|
23
|
+
readonly valueHint: "pasta";
|
|
24
|
+
readonly description: "Pasta do projeto, a que tem o src. Padrão: a pasta atual.";
|
|
25
|
+
};
|
|
26
|
+
readonly 'dry-run': {
|
|
27
|
+
readonly type: "boolean";
|
|
28
|
+
readonly description: "Só lista o que seria criado e alterado, sem escrever nada.";
|
|
29
|
+
};
|
|
30
|
+
}>;
|
|
@@ -0,0 +1,73 @@
|
|
|
1
|
+
import { defineCommand } from 'citty';
|
|
2
|
+
import path from 'node:path';
|
|
3
|
+
import { generatePage } from "../generate/page.js";
|
|
4
|
+
import { findProject } from "../project.js";
|
|
5
|
+
import { finishWithCheck, formatSummary, testCommandFor } from "./shared.js";
|
|
6
|
+
/**
|
|
7
|
+
* `prumo make:page <nome> [--domain <domínio>]`: gera uma tela a partir dos modelos do pacote
|
|
8
|
+
* (nunca copiando outra tela do projeto): `index`, `model`, `view` e o teste, as mensagens nos
|
|
9
|
+
* idiomas do projeto, o namespace nos índices de mensagens e a rota no `src/App.tsx`. Valida tudo
|
|
10
|
+
* antes de escrever, então um erro de uso (saída 2) não deixa o projeto pela metade, e `--dry-run`
|
|
11
|
+
* só lista o que seria feito. Ao terminar, roda o `prumo check`; com violação sai com 1, já com a
|
|
12
|
+
* tela gerada.
|
|
13
|
+
*/
|
|
14
|
+
export function createMakePageCommand(runtime) {
|
|
15
|
+
return defineCommand({
|
|
16
|
+
meta: {
|
|
17
|
+
name: 'make:page',
|
|
18
|
+
description: `Gera uma tela nova: index, model, view, teste, mensagens e rota.
|
|
19
|
+
|
|
20
|
+
Cria src/pages/<nome>/ com o index.tsx (liga o model à view), o model.ts (dados e textos, sem JSX),
|
|
21
|
+
a view.tsx (só elementos HTML semânticos, recebe tudo por props) e o index.test.tsx (renderiza com o
|
|
22
|
+
renderWithProviders do projeto, de @/test/render, e confere o título). Cria as mensagens em
|
|
23
|
+
src/messages/<idioma>/<nome>.json (title e os textos da tela), registra o namespace nos índices de
|
|
24
|
+
mensagens de cada idioma e a rota /<nome> no src/App.tsx.
|
|
25
|
+
|
|
26
|
+
O nome é o da tela, em kebab-case (clientes, pedidos-recentes). Com --domain <domínio>, o model lê
|
|
27
|
+
a lista do domínio (use<Domínio>List, de @/queries, criado por make:domain) e a view mostra o
|
|
28
|
+
carregando, o erro e a lista; sem ele, a tela só tem o título.
|
|
29
|
+
|
|
30
|
+
Valida tudo antes de escrever e recusa sobrescrever. Ao terminar, roda o prumo check e mostra o
|
|
31
|
+
comando dos testes da tela nova. Sai com código 1 se o check achar violação (a tela já foi gerada)
|
|
32
|
+
e com 2 se o uso está errado: nome inválido ou reservado, tela que já existe, domínio que falta,
|
|
33
|
+
App.tsx ou índice de mensagens que falta.`,
|
|
34
|
+
},
|
|
35
|
+
args: {
|
|
36
|
+
nome: {
|
|
37
|
+
type: 'positional',
|
|
38
|
+
required: true,
|
|
39
|
+
description: 'Nome da tela, em kebab-case (por exemplo, clientes).',
|
|
40
|
+
},
|
|
41
|
+
domain: {
|
|
42
|
+
type: 'string',
|
|
43
|
+
valueHint: 'domínio',
|
|
44
|
+
description: 'Domínio cuja lista a tela mostra (por exemplo, clientes). Padrão: nenhum.',
|
|
45
|
+
},
|
|
46
|
+
root: {
|
|
47
|
+
type: 'string',
|
|
48
|
+
valueHint: 'pasta',
|
|
49
|
+
description: 'Pasta do projeto, a que tem o src. Padrão: a pasta atual.',
|
|
50
|
+
},
|
|
51
|
+
'dry-run': {
|
|
52
|
+
type: 'boolean',
|
|
53
|
+
description: 'Só lista o que seria criado e alterado, sem escrever nada.',
|
|
54
|
+
},
|
|
55
|
+
},
|
|
56
|
+
run({ args }) {
|
|
57
|
+
const project = findProject(path.resolve(runtime.cwd, args.root ?? '.'));
|
|
58
|
+
const { plan, names, domain, route } = generatePage(project, {
|
|
59
|
+
name: args.nome,
|
|
60
|
+
domain: args.domain,
|
|
61
|
+
});
|
|
62
|
+
const heading = `prumo make:page: ${names.kebab} (rota ${route}${domain ? `, domínio ${domain.kebab}` : ''}).`;
|
|
63
|
+
if (args['dry-run']) {
|
|
64
|
+
runtime.out(`${heading}\n\n${formatSummary(plan.summary(), true)}\nSimulação (--dry-run): nada foi escrito.\n`);
|
|
65
|
+
return;
|
|
66
|
+
}
|
|
67
|
+
const summary = plan.commit();
|
|
68
|
+
runtime.out(`${heading}\n\n${formatSummary(summary, false)}\n`);
|
|
69
|
+
const next = `Edite o model (src/pages/${names.kebab}/model.ts), a view (view.tsx) e os textos (src/messages/<idioma>/${names.kebab}.json); o teste acompanha.\n\nPara rodar os testes da tela nova:\n ${testCommandFor(project, runtime.cwd, `src/pages/${names.kebab}`)}\n`;
|
|
70
|
+
finishWithCheck(runtime, project, { generated: 'a tela foi gerada', next });
|
|
71
|
+
},
|
|
72
|
+
});
|
|
73
|
+
}
|
|
@@ -0,0 +1,33 @@
|
|
|
1
|
+
import type { Runtime } from '../runtime.js';
|
|
2
|
+
/**
|
|
3
|
+
* `prumo new <nome>`: cria um app mínimo do Prumo. Monta o app numa pasta de rascunho (os modelos, o
|
|
4
|
+
* `package.json` e a tela inicial, que sai do mesmo modelo do `make:page`), e só se tudo deu certo o
|
|
5
|
+
* leva para `<dir>/<nome>`: um erro não deixa pasta pela metade. Depois roda `git init` (sem commit)
|
|
6
|
+
* e `pnpm install`, a não ser com `--no-install`.
|
|
7
|
+
*/
|
|
8
|
+
export declare function createNewCommand(runtime: Runtime): import("citty").CommandDef<{
|
|
9
|
+
readonly nome: {
|
|
10
|
+
readonly type: "positional";
|
|
11
|
+
readonly required: true;
|
|
12
|
+
readonly description: "O nome do app, em kebab-case (meu-app): a pasta e o nome do pacote.";
|
|
13
|
+
};
|
|
14
|
+
readonly dir: {
|
|
15
|
+
readonly type: "string";
|
|
16
|
+
readonly valueHint: "pasta";
|
|
17
|
+
readonly description: "A pasta onde criar <nome>. Padrão: a pasta atual.";
|
|
18
|
+
};
|
|
19
|
+
readonly packages: {
|
|
20
|
+
readonly type: "string";
|
|
21
|
+
readonly valueHint: "pasta";
|
|
22
|
+
readonly description: "Uma pasta com os tarballs dos pacotes @matizze/prumo-* (pnpm pack:all), instalados no lugar do registry.";
|
|
23
|
+
};
|
|
24
|
+
readonly install: {
|
|
25
|
+
readonly type: "boolean";
|
|
26
|
+
readonly default: true;
|
|
27
|
+
readonly description: "Com --no-install, não roda o pnpm install: só cria os arquivos. Sem a opção, instala.";
|
|
28
|
+
};
|
|
29
|
+
readonly 'dry-run': {
|
|
30
|
+
readonly type: "boolean";
|
|
31
|
+
readonly description: "Só lista o que seria criado, sem escrever nada.";
|
|
32
|
+
};
|
|
33
|
+
}>;
|
|
@@ -0,0 +1,179 @@
|
|
|
1
|
+
import { spawnSync } from 'node:child_process';
|
|
2
|
+
import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, statSync } from 'node:fs';
|
|
3
|
+
import { tmpdir } from 'node:os';
|
|
4
|
+
import path from 'node:path';
|
|
5
|
+
import { defineCommand } from 'citty';
|
|
6
|
+
import { ExitError, UsageError } from "../errors.js";
|
|
7
|
+
import { generateApp } from "../generate/app.js";
|
|
8
|
+
import { appNameProblem } from "../new/name.js";
|
|
9
|
+
import { readTarballs } from "../new/packages.js";
|
|
10
|
+
import { childEnv, runChild } from "../process.js";
|
|
11
|
+
import { shellQuote } from "./shared.js";
|
|
12
|
+
/**
|
|
13
|
+
* Valida o destino: `<dir>/<nome>` não pode existir com conteúdo (uma pasta vazia serve), e o pai
|
|
14
|
+
* não pode ser um arquivo. Devolve o caminho absoluto.
|
|
15
|
+
*/
|
|
16
|
+
function resolveDestination(runtime, dir, name) {
|
|
17
|
+
const parent = path.resolve(runtime.cwd, dir ?? '.');
|
|
18
|
+
if (existsSync(parent) && !statSync(parent).isDirectory()) {
|
|
19
|
+
throw new UsageError(`'${parent}' não é uma pasta (--dir).`);
|
|
20
|
+
}
|
|
21
|
+
const destination = path.join(parent, name);
|
|
22
|
+
if (existsSync(destination)) {
|
|
23
|
+
if (!statSync(destination).isDirectory()) {
|
|
24
|
+
throw new UsageError(`'${destination}' já existe e não é uma pasta.`);
|
|
25
|
+
}
|
|
26
|
+
if (readdirSync(destination).length > 0) {
|
|
27
|
+
throw new UsageError(`a pasta '${destination}' já existe e não está vazia: escolha outro nome ou outra pasta (--dir).`);
|
|
28
|
+
}
|
|
29
|
+
}
|
|
30
|
+
return destination;
|
|
31
|
+
}
|
|
32
|
+
/**
|
|
33
|
+
* `prumo new <nome>`: cria um app mínimo do Prumo. Monta o app numa pasta de rascunho (os modelos, o
|
|
34
|
+
* `package.json` e a tela inicial, que sai do mesmo modelo do `make:page`), e só se tudo deu certo o
|
|
35
|
+
* leva para `<dir>/<nome>`: um erro não deixa pasta pela metade. Depois roda `git init` (sem commit)
|
|
36
|
+
* e `pnpm install`, a não ser com `--no-install`.
|
|
37
|
+
*/
|
|
38
|
+
export function createNewCommand(runtime) {
|
|
39
|
+
return defineCommand({
|
|
40
|
+
meta: {
|
|
41
|
+
name: 'new',
|
|
42
|
+
description: `Cria um app React mínimo do Prumo, sem CSS e sem design system.
|
|
43
|
+
|
|
44
|
+
Cria <dir>/<nome> com Vite, React 19, TypeScript, wouter, TanStack Query, zod e i18next (o que o
|
|
45
|
+
@matizze/prumo-core usa), os pacotes do Prumo (core, rules, testing, cli e mcp), a estrutura de pastas
|
|
46
|
+
(src/pages, src/components/shared, src/schemas, src/repositories, src/queries e src/messages), os
|
|
47
|
+
provedores (query, i18n e repositórios), uma tela inicial (a mesma que o prumo make:page gera, na
|
|
48
|
+
rota /), o eslint com o plugin do Prumo, o vitest com jsdom, o AGENTS.md e o .mcp.json com o servidor
|
|
49
|
+
prumo, que dá a um agente os comandos da CLI.
|
|
50
|
+
|
|
51
|
+
Os scripts do app são dev, build, typecheck, lint, check, test e verify (typecheck, lint, check e
|
|
52
|
+
test, sem navegador). Os pacotes do Prumo entram como ^<versão>; com --packages, o app instala os
|
|
53
|
+
tarballs da pasta (pnpm.overrides com file:), o que serve a quem ainda não tem os pacotes num
|
|
54
|
+
registry. Roda git init (sem commit) e pnpm install, a não ser com --no-install.
|
|
55
|
+
|
|
56
|
+
Valida antes de escrever: o nome (kebab-case), a pasta de destino (não pode existir com conteúdo) e
|
|
57
|
+
os tarballs saem com código 2, sem deixar nada pela metade. --dry-run lista o que seria criado e não
|
|
58
|
+
escreve nada. Os tarballs de --packages saem do pnpm pack:all, no monorepo do Prumo.`,
|
|
59
|
+
},
|
|
60
|
+
args: {
|
|
61
|
+
nome: {
|
|
62
|
+
type: 'positional',
|
|
63
|
+
required: true,
|
|
64
|
+
description: 'O nome do app, em kebab-case (meu-app): a pasta e o nome do pacote.',
|
|
65
|
+
},
|
|
66
|
+
dir: {
|
|
67
|
+
type: 'string',
|
|
68
|
+
valueHint: 'pasta',
|
|
69
|
+
description: 'A pasta onde criar <nome>. Padrão: a pasta atual.',
|
|
70
|
+
},
|
|
71
|
+
packages: {
|
|
72
|
+
type: 'string',
|
|
73
|
+
valueHint: 'pasta',
|
|
74
|
+
description: 'Uma pasta com os tarballs dos pacotes @matizze/prumo-* (pnpm pack:all), instalados no lugar do registry.',
|
|
75
|
+
},
|
|
76
|
+
install: {
|
|
77
|
+
type: 'boolean',
|
|
78
|
+
default: true,
|
|
79
|
+
description: 'Com --no-install, não roda o pnpm install: só cria os arquivos. Sem a opção, instala.',
|
|
80
|
+
},
|
|
81
|
+
'dry-run': {
|
|
82
|
+
type: 'boolean',
|
|
83
|
+
description: 'Só lista o que seria criado, sem escrever nada.',
|
|
84
|
+
},
|
|
85
|
+
},
|
|
86
|
+
run({ args }) {
|
|
87
|
+
const name = String(args.nome);
|
|
88
|
+
const dryRun = Boolean(args['dry-run']);
|
|
89
|
+
const install = args.install !== false;
|
|
90
|
+
// Tudo que dá para conferir, antes de escrever qualquer coisa
|
|
91
|
+
const problem = appNameProblem(name);
|
|
92
|
+
if (problem)
|
|
93
|
+
throw new UsageError(problem);
|
|
94
|
+
const destination = resolveDestination(runtime, args.dir, name);
|
|
95
|
+
const overrides = args.packages === undefined
|
|
96
|
+
? undefined
|
|
97
|
+
: readTarballs(path.resolve(runtime.cwd, args.packages));
|
|
98
|
+
// O app inteiro é montado numa pasta de rascunho e só vai ao destino se nada falhou
|
|
99
|
+
const scratch = mkdtempSync(path.join(tmpdir(), 'prumo-new-'));
|
|
100
|
+
let files;
|
|
101
|
+
try {
|
|
102
|
+
const root = path.join(scratch, name);
|
|
103
|
+
files = generateApp(root, { name, overrides });
|
|
104
|
+
if (!dryRun) {
|
|
105
|
+
mkdirSync(path.dirname(destination), { recursive: true });
|
|
106
|
+
const createdFolder = !existsSync(destination);
|
|
107
|
+
try {
|
|
108
|
+
cpSync(root, destination, { recursive: true });
|
|
109
|
+
}
|
|
110
|
+
catch (error) {
|
|
111
|
+
rollback(destination, createdFolder);
|
|
112
|
+
throw error;
|
|
113
|
+
}
|
|
114
|
+
}
|
|
115
|
+
}
|
|
116
|
+
finally {
|
|
117
|
+
rmSync(scratch, { recursive: true, force: true });
|
|
118
|
+
}
|
|
119
|
+
const packagesLine = overrides
|
|
120
|
+
? `Pacotes do Prumo: tarballs de ${path.resolve(runtime.cwd, String(args.packages))} (pnpm.overrides com file:).`
|
|
121
|
+
: 'Pacotes do Prumo: do registry, pela versão (^<versão>) no package.json.';
|
|
122
|
+
const heading = `prumo new: ${name}${dryRun ? ' (simulação)' : ''}.\nDestino: ${destination}\n`;
|
|
123
|
+
const list = `${dryRun ? 'Seriam criados' : 'Criados'} (${files.length}):\n${files.map((file) => ` ${file}`).join('\n')}\n`;
|
|
124
|
+
if (dryRun) {
|
|
125
|
+
runtime.out(`${heading}\n${list}\n${packagesLine}\n\n${install ? 'Depois: git init e pnpm install.\n\n' : 'Depois: git init (sem pnpm install, por --no-install).\n\n'}Simulação (--dry-run): nada foi escrito.\n`);
|
|
126
|
+
return;
|
|
127
|
+
}
|
|
128
|
+
runtime.out(`${heading}\n${list}\n${packagesLine}\n`);
|
|
129
|
+
initGit(runtime, destination);
|
|
130
|
+
if (install)
|
|
131
|
+
installPackages(runtime, destination);
|
|
132
|
+
runtime.out(nextSteps(runtime, destination, install));
|
|
133
|
+
},
|
|
134
|
+
});
|
|
135
|
+
}
|
|
136
|
+
/** Desfaz a escrita que falhou: apaga a pasta se o comando a criou, ou o que pôs numa pasta vazia. */
|
|
137
|
+
function rollback(destination, createdFolder) {
|
|
138
|
+
if (createdFolder) {
|
|
139
|
+
rmSync(destination, { recursive: true, force: true });
|
|
140
|
+
return;
|
|
141
|
+
}
|
|
142
|
+
for (const entry of readdirSync(destination)) {
|
|
143
|
+
rmSync(path.join(destination, entry), { recursive: true, force: true });
|
|
144
|
+
}
|
|
145
|
+
}
|
|
146
|
+
/** `git init`, sem commit: quem criou o app decide o primeiro commit. Falhar só avisa. */
|
|
147
|
+
function initGit(runtime, destination) {
|
|
148
|
+
const result = spawnSync('git', ['init', '--quiet'], {
|
|
149
|
+
cwd: destination,
|
|
150
|
+
encoding: 'utf8',
|
|
151
|
+
env: childEnv(runtime),
|
|
152
|
+
});
|
|
153
|
+
if (result.error || result.status !== 0) {
|
|
154
|
+
runtime.err(`prumo new: não consegui rodar git init em '${destination}': ${result.error?.message ?? result.stderr.trim()}\n`);
|
|
155
|
+
}
|
|
156
|
+
}
|
|
157
|
+
/** `pnpm install` no app, com a saída no terminal (ou em `runtime.out` e `runtime.err`, fora dele). Falhar deixa o app criado e diz como seguir. */
|
|
158
|
+
function installPackages(runtime, destination) {
|
|
159
|
+
runtime.out('\nInstalando as dependências (pnpm install)...\n');
|
|
160
|
+
const result = runChild(runtime, 'pnpm', ['install'], { cwd: destination });
|
|
161
|
+
if (result.error || result.status !== 0) {
|
|
162
|
+
throw new ExitError(1, `o pnpm install falhou${result.error ? ` (${result.error.message})` : ''}. O app foi criado em '${destination}': corrija o que o pnpm disse e rode pnpm install ali.`);
|
|
163
|
+
}
|
|
164
|
+
}
|
|
165
|
+
/** O que fazer depois: entrar na pasta, instalar se faltou, conferir, subir o app e gerar o primeiro domínio. */
|
|
166
|
+
function nextSteps(runtime, destination, installed) {
|
|
167
|
+
const relative = path.relative(runtime.cwd, destination);
|
|
168
|
+
const folder = shellQuote(relative.startsWith('..') ? destination : relative);
|
|
169
|
+
const steps = [
|
|
170
|
+
`cd ${folder}`,
|
|
171
|
+
...(installed ? [] : ['pnpm install']),
|
|
172
|
+
'pnpm verify # typecheck, lint, check e test',
|
|
173
|
+
'pnpm dev # o app em http://localhost:5173',
|
|
174
|
+
'pnpm exec prumo make:domain clientes # um domínio de dados (schema, repositório e queries)',
|
|
175
|
+
'pnpm exec prumo make:page clientes --domain clientes # uma tela que lista o domínio',
|
|
176
|
+
];
|
|
177
|
+
const agent = 'Um agente de IA (o Claude Code, por exemplo) lê o .mcp.json deste app e ganha o servidor prumo: cada comando da CLI vira uma ferramenta (mcp__prumo__make_page, mcp__prumo__check...).';
|
|
178
|
+
return `\nPróximos passos:\n${steps.map((step) => ` ${step}`).join('\n')}\n\n${agent}\n`;
|
|
179
|
+
}
|
|
@@ -0,0 +1,43 @@
|
|
|
1
|
+
import { type Violation } from '@matizze/prumo-rules/check';
|
|
2
|
+
import type { PlanSummary } from '../codemod/index.js';
|
|
3
|
+
import type { Project } from '../project.js';
|
|
4
|
+
import type { Runtime } from '../runtime.js';
|
|
5
|
+
/** O que o plano criou e alterou, em texto. `dryRun` troca os verbos para o futuro do pretérito. */
|
|
6
|
+
export declare function formatSummary({ created, modified }: PlanSummary, dryRun: boolean): string;
|
|
7
|
+
/**
|
|
8
|
+
* O caminho como o shell o lê: sem mudança se só tem caracteres seguros, e entre aspas simples
|
|
9
|
+
* (com `'` escrito como `'\''`) se tem espaço ou outro caractere especial. Sem isso, o comando
|
|
10
|
+
* impresso, copiado para o terminal, quebraria num projeto com espaço no caminho.
|
|
11
|
+
*/
|
|
12
|
+
export declare function shellQuote(value: string): string;
|
|
13
|
+
/**
|
|
14
|
+
* O comando do `pnpm` para o projeto, no mesmo terminal onde o comando do `prumo` rodou: `pnpm
|
|
15
|
+
* <comando>` na pasta do projeto e, fora dela, `pnpm --dir <pasta> <comando>`. Fora da pasta atual,
|
|
16
|
+
* o caminho absoluto é mais claro que uma subida de várias pastas.
|
|
17
|
+
*/
|
|
18
|
+
export declare function pnpmCommand(project: Project, cwd: string, command: string): string;
|
|
19
|
+
/**
|
|
20
|
+
* O comando que roda os testes de uma pasta ou de um arquivo do projeto (`src/pages/produtos`),
|
|
21
|
+
* para o mesmo terminal onde o `make:*` rodou: usa o script `test` do projeto, se houver, e o
|
|
22
|
+
* Vitest direto, se não.
|
|
23
|
+
*/
|
|
24
|
+
export declare function testCommandFor(project: Project, cwd: string, target: string): string;
|
|
25
|
+
/** Uma violação que o comando já espera do que gerou: ela é mostrada, mas não faz o comando falhar. */
|
|
26
|
+
export interface ExpectedViolation {
|
|
27
|
+
matches: (violation: Violation) => boolean;
|
|
28
|
+
/** A frase que abre a lista, depois de `prumo check:` (`só a violação esperada ...:`). */
|
|
29
|
+
intro: string;
|
|
30
|
+
/** O que a pessoa precisa saber sobre ela, depois da lista. */
|
|
31
|
+
note: string;
|
|
32
|
+
}
|
|
33
|
+
/**
|
|
34
|
+
* O fim de um comando `make:*`: roda o `prumo check` no projeto e escreve o resultado, seguido do
|
|
35
|
+
* `next` (o que fazer agora). Sem violação, sai normalmente. Com violação, escreve cada uma no
|
|
36
|
+
* stderr e sai com 1, já com os arquivos gerados (`generated`: `a tela foi gerada`). As violações
|
|
37
|
+
* que `expected` reconhece não contam como falha: o comando as mostra e explica.
|
|
38
|
+
*/
|
|
39
|
+
export declare function finishWithCheck(runtime: Runtime, project: Project, { generated, next, expected }: {
|
|
40
|
+
generated: string;
|
|
41
|
+
next: string;
|
|
42
|
+
expected?: ExpectedViolation;
|
|
43
|
+
}): void;
|