@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.
Files changed (124) hide show
  1. package/README.md +120 -2
  2. package/dist/api.d.ts +10 -0
  3. package/dist/api.js +9 -0
  4. package/dist/args.d.ts +11 -0
  5. package/dist/args.js +61 -0
  6. package/dist/bin.d.ts +2 -0
  7. package/dist/bin.js +11 -0
  8. package/dist/codemod/add-route.d.ts +66 -0
  9. package/dist/codemod/add-route.js +435 -0
  10. package/dist/codemod/edit.d.ts +35 -0
  11. package/dist/codemod/edit.js +51 -0
  12. package/dist/codemod/index.d.ts +8 -0
  13. package/dist/codemod/index.js +8 -0
  14. package/dist/codemod/merge-barrel.d.ts +9 -0
  15. package/dist/codemod/merge-barrel.js +49 -0
  16. package/dist/codemod/messages.d.ts +11 -0
  17. package/dist/codemod/messages.js +46 -0
  18. package/dist/codemod/names.d.ts +62 -0
  19. package/dist/codemod/names.js +204 -0
  20. package/dist/codemod/plan.d.ts +45 -0
  21. package/dist/codemod/plan.js +147 -0
  22. package/dist/codemod/register-domain.d.ts +51 -0
  23. package/dist/codemod/register-domain.js +237 -0
  24. package/dist/codemod/register-messages.d.ts +11 -0
  25. package/dist/codemod/register-messages.js +112 -0
  26. package/dist/codemod/route-elements.d.ts +25 -0
  27. package/dist/codemod/route-elements.js +72 -0
  28. package/dist/commands/check.d.ts +16 -0
  29. package/dist/commands/check.js +47 -0
  30. package/dist/commands/doctor.d.ts +20 -0
  31. package/dist/commands/doctor.js +104 -0
  32. package/dist/commands/make-component.d.ts +33 -0
  33. package/dist/commands/make-component.js +85 -0
  34. package/dist/commands/make-domain.d.ts +30 -0
  35. package/dist/commands/make-domain.js +83 -0
  36. package/dist/commands/make-page.d.ts +30 -0
  37. package/dist/commands/make-page.js +73 -0
  38. package/dist/commands/new.d.ts +33 -0
  39. package/dist/commands/new.js +179 -0
  40. package/dist/commands/shared.d.ts +43 -0
  41. package/dist/commands/shared.js +83 -0
  42. package/dist/describe.d.ts +63 -0
  43. package/dist/describe.js +134 -0
  44. package/dist/doctor/checks.d.ts +35 -0
  45. package/dist/doctor/checks.js +283 -0
  46. package/dist/doctor/ranges.d.ts +16 -0
  47. package/dist/doctor/ranges.js +27 -0
  48. package/dist/doctor/versions.d.ts +33 -0
  49. package/dist/doctor/versions.js +44 -0
  50. package/dist/errors.d.ts +12 -0
  51. package/dist/errors.js +19 -0
  52. package/dist/generate/app.d.ts +27 -0
  53. package/dist/generate/app.js +136 -0
  54. package/dist/generate/component.d.ts +36 -0
  55. package/dist/generate/component.js +48 -0
  56. package/dist/generate/domain.d.ts +31 -0
  57. package/dist/generate/domain.js +63 -0
  58. package/dist/generate/page.d.ts +45 -0
  59. package/dist/generate/page.js +100 -0
  60. package/dist/help.d.ts +19 -0
  61. package/dist/help.js +97 -0
  62. package/dist/in-process.d.ts +26 -0
  63. package/dist/in-process.js +23 -0
  64. package/dist/index.d.ts +9 -0
  65. package/dist/index.js +9 -0
  66. package/dist/new/name.d.ts +7 -0
  67. package/dist/new/name.js +24 -0
  68. package/dist/new/packages.d.ts +6 -0
  69. package/dist/new/packages.js +40 -0
  70. package/dist/new/versions.d.ts +7 -0
  71. package/dist/new/versions.js +13 -0
  72. package/dist/process.d.ts +22 -0
  73. package/dist/process.js +45 -0
  74. package/dist/project.d.ts +22 -0
  75. package/dist/project.js +42 -0
  76. package/dist/root.d.ts +3 -0
  77. package/dist/root.js +24 -0
  78. package/dist/run.d.ts +13 -0
  79. package/dist/run.js +72 -0
  80. package/dist/runtime.d.ts +19 -0
  81. package/dist/runtime.js +1 -0
  82. package/dist/templates.d.ts +26 -0
  83. package/dist/templates.js +46 -0
  84. package/package.json +45 -3
  85. package/templates/app/AGENTS.md.tpl +50 -0
  86. package/templates/app/README.md.tpl +15 -0
  87. package/templates/app/eslint.config.js.tpl +19 -0
  88. package/templates/app/gitignore.tpl +22 -0
  89. package/templates/app/index.html.tpl +12 -0
  90. package/templates/app/mcp.json.tpl +8 -0
  91. package/templates/app/src/App.tsx.tpl +8 -0
  92. package/templates/app/src/i18n.ts.tpl +12 -0
  93. package/templates/app/src/main.tsx.tpl +12 -0
  94. package/templates/app/src/messages/index.ts.tpl +1 -0
  95. package/templates/app/src/providers/app.tsx.tpl +23 -0
  96. package/templates/app/src/providers/repository/index.ts.tpl +5 -0
  97. package/templates/app/src/queries-index.ts.tpl +1 -0
  98. package/templates/app/src/repositories/index.ts.tpl +18 -0
  99. package/templates/app/src/repositories/options.ts.tpl +8 -0
  100. package/templates/app/src/schemas-index.ts.tpl +1 -0
  101. package/templates/app/src/test/render.tsx.tpl +31 -0
  102. package/templates/app/src/test/setup.ts.tpl +4 -0
  103. package/templates/app/typescript.json.tpl +24 -0
  104. package/templates/app/vite.config.ts.tpl +16 -0
  105. package/templates/component/component-test.tsx.tpl +9 -0
  106. package/templates/component/component.tsx.tpl +11 -0
  107. package/templates/domain/queries.ts.tpl +62 -0
  108. package/templates/domain/repository-contract-test.ts.tpl +75 -0
  109. package/templates/domain/repository-contract.ts.tpl +13 -0
  110. package/templates/domain/repository-fixtures.ts.tpl +8 -0
  111. package/templates/domain/repository-index.ts.tpl +12 -0
  112. package/templates/domain/repository-mock.ts.tpl +69 -0
  113. package/templates/domain/schema.ts.tpl +23 -0
  114. package/templates/page/index-domain-test.tsx.tpl +11 -0
  115. package/templates/page/index-test.tsx.tpl +10 -0
  116. package/templates/page/index.tsx.tpl +7 -0
  117. package/templates/page/messages-domain.en.json.tpl +5 -0
  118. package/templates/page/messages-domain.pt-BR.json.tpl +5 -0
  119. package/templates/page/messages.en.json.tpl +3 -0
  120. package/templates/page/messages.pt-BR.json.tpl +3 -0
  121. package/templates/page/model-domain.ts.tpl +17 -0
  122. package/templates/page/model.ts.tpl +8 -0
  123. package/templates/page/view-domain.tsx.tpl +20 -0
  124. package/templates/page/view.tsx.tpl +9 -0
@@ -0,0 +1,237 @@
1
+ import path from 'node:path';
2
+ import { Node } from 'ts-morph';
3
+ import { UsageError } from "../errors.js";
4
+ import { afterComma, applyEdits, indentOf } from "./edit.js";
5
+ /** Um arquivo do índice de um domínio, relativo à raiz, para as mensagens de erro. */
6
+ function display(plan, file) {
7
+ return path.relative(plan.project.root, file).split(path.sep).join('/');
8
+ }
9
+ /** O nome do módulo de um import ou export, ou `''` se não tiver (`export { x }` sem `from`). */
10
+ function specifierOf(declaration) {
11
+ return declaration.getModuleSpecifierValue() ?? '';
12
+ }
13
+ /** O arquivo de índice, que precisa existir. */
14
+ function indexSource(plan, file) {
15
+ try {
16
+ return plan.source(file);
17
+ }
18
+ catch {
19
+ throw new UsageError(`o projeto não tem ${display(plan, file)}.`);
20
+ }
21
+ }
22
+ /**
23
+ * A edição que acrescenta `line` como uma declaração do topo do arquivo, na posição alfabética:
24
+ * antes da primeira declaração que vem depois da nova (pelo módulo), ou depois da última, se
25
+ * nenhuma vem. Sem nenhuma declaração do grupo, vai depois de `fallback`.
26
+ */
27
+ function insertSorted(group, specifier, line, fallback, where) {
28
+ const next = group.find((declaration) => specifierOf(declaration) > specifier);
29
+ if (next)
30
+ return { pos: next.getStart(), end: next.getStart(), text: `${line}\n` };
31
+ const last = group[group.length - 1] ?? fallback;
32
+ if (!last)
33
+ throw new UsageError(`não achei onde acrescentar '${specifier}' em ${where}.`);
34
+ return { pos: last.getEnd(), end: last.getEnd(), text: `\n${line}` };
35
+ }
36
+ /**
37
+ * A edição que acrescenta `line` no fim do arquivo, em linha própria. É o caso do índice que ainda
38
+ * não tem nenhum export (o de um projeto novo, sem domínios): um arquivo vazio ou só com comentários.
39
+ */
40
+ function appendLine(file, line) {
41
+ const text = file.getFullText();
42
+ const end = text.length;
43
+ return { pos: end, end, text: `${text === '' || text.endsWith('\n') ? '' : '\n'}${line}\n` };
44
+ }
45
+ /** As aspas e o ponto e vírgula do estilo do arquivo, copiados de uma declaração com módulo. */
46
+ function styleOf(declaration) {
47
+ const specifier = declaration?.getModuleSpecifier();
48
+ return {
49
+ quote: specifier ? specifier.getText().charAt(0) : "'",
50
+ semicolon: declaration?.getText().endsWith(';') ? ';' : '',
51
+ };
52
+ }
53
+ /**
54
+ * O `export * from './entities/<entidade>'` no fim de `src/schemas/index.ts`. A ordem do arquivo
55
+ * é a em que as entidades chegaram, e não a alfabética: o export novo vai depois do último (ou no
56
+ * fim do arquivo, se ele ainda não tem nenhum).
57
+ */
58
+ export function registerSchema(plan, to) {
59
+ const file = path.join(plan.project.src, 'schemas', 'index.ts');
60
+ const where = display(plan, file);
61
+ const index = indexSource(plan, file);
62
+ const specifier = `./entities/${to.singular.kebab}`;
63
+ const exports = index.getExportDeclarations();
64
+ if (exports.some((declaration) => specifierOf(declaration) === specifier)) {
65
+ throw new UsageError(`${where} já exporta '${specifier}'.`);
66
+ }
67
+ const last = exports[exports.length - 1];
68
+ const { quote, semicolon } = styleOf(last);
69
+ const line = `export * from ${quote}${specifier}${quote}${semicolon}`;
70
+ // Sem nenhum export (o índice de um projeto novo), o primeiro vai no fim do arquivo
71
+ applyEdits(index, [
72
+ last ? { pos: last.getEnd(), end: last.getEnd(), text: `\n${line}` } : appendLine(index, line),
73
+ ]);
74
+ }
75
+ /** O mapa `factories` de `src/repositories/index.ts`. */
76
+ function factoriesObject(index, where) {
77
+ const initializer = index.getVariableDeclaration('factories')?.getInitializer();
78
+ if (!initializer || !Node.isObjectLiteralExpression(initializer)) {
79
+ throw new UsageError(`${where} não tem o mapa 'const factories = { ... }'.`);
80
+ }
81
+ return initializer;
82
+ }
83
+ /** O nome de uma propriedade do mapa: `customers` em `customers: createCustomersRepository`. */
84
+ function propertyName(property) {
85
+ if (Node.isPropertyAssignment(property) || Node.isShorthandPropertyAssignment(property)) {
86
+ return property.getName();
87
+ }
88
+ return undefined;
89
+ }
90
+ /**
91
+ * Se `src/repositories/index.ts` já exporta a pasta do repositório (`export * from './<pasta>'`).
92
+ * É como o `prumo add` sabe que o domínio já está registrado.
93
+ */
94
+ export function isRepositoryRegistered(plan, directory) {
95
+ const index = indexSource(plan, path.join(plan.project.src, 'repositories', 'index.ts'));
96
+ return index
97
+ .getExportDeclarations()
98
+ .some((declaration) => specifierOf(declaration) === `./${directory}`);
99
+ }
100
+ /**
101
+ * Registra o repositório em `src/repositories/index.ts`: o `import { <fábrica> }`, o `export *
102
+ * from` da pasta e a entrada `<chave>: <fábrica>` no mapa `factories`, cada um na posição
103
+ * alfabética. O tipo do container acompanha o mapa sozinho.
104
+ */
105
+ export function registerRepositoryEntry(plan, entry) {
106
+ const file = path.join(plan.project.src, 'repositories', 'index.ts');
107
+ const where = display(plan, file);
108
+ const index = indexSource(plan, file);
109
+ const specifier = `./${entry.directory}`;
110
+ const { factory, key } = entry;
111
+ const imports = index.getImportDeclarations();
112
+ const relativeImports = imports.filter((declaration) => specifierOf(declaration).startsWith('./'));
113
+ // `export * from './x'`, sem nomes: o `export { ... } from './options'` não entra
114
+ const reExports = index
115
+ .getExportDeclarations()
116
+ .filter((declaration) => declaration.hasModuleSpecifier() &&
117
+ !declaration.hasNamedExports() &&
118
+ declaration.getNamespaceExport() === undefined);
119
+ if (reExports.some((declaration) => specifierOf(declaration) === specifier)) {
120
+ throw new UsageError(`${where} já exporta '${specifier}'.`);
121
+ }
122
+ const factories = factoriesObject(index, where);
123
+ const properties = factories.getProperties();
124
+ if (properties.some((property) => propertyName(property) === key)) {
125
+ throw new UsageError(`${where} já tem o domínio '${key}' no mapa factories.`);
126
+ }
127
+ const importStyle = styleOf(relativeImports[0] ?? imports[0]);
128
+ const exportStyle = styleOf(reExports[0] ?? relativeImports[0] ?? imports[0]);
129
+ const importLine = `import { ${factory} } from ${importStyle.quote}${specifier}${importStyle.quote}${importStyle.semicolon}`;
130
+ const exportLine = `export * from ${exportStyle.quote}${specifier}${exportStyle.quote}${exportStyle.semicolon}`;
131
+ const last = properties[properties.length - 1];
132
+ const indent = last ? indentOf(index.getFullText(), last.getStart()) : ' ';
133
+ const next = properties.find((property) => (propertyName(property) ?? '') > key);
134
+ const mapEntry = `${key}: ${factory}`;
135
+ let factoryEdit;
136
+ if (next) {
137
+ factoryEdit = { pos: next.getStart(), end: next.getStart(), text: `${mapEntry},\n${indent}` };
138
+ }
139
+ else if (last) {
140
+ const { end, hasComma } = afterComma(index.getFullText(), last.getEnd());
141
+ factoryEdit = {
142
+ pos: end,
143
+ end,
144
+ text: `${hasComma ? '' : ','}\n${indent}${mapEntry}${hasComma ? ',' : ''}`,
145
+ };
146
+ }
147
+ else {
148
+ const open = factories.getStart() + 1;
149
+ factoryEdit = { pos: open, end: open, text: `\n${indent}${mapEntry},\n` };
150
+ }
151
+ // Sem nenhum `export *` (o índice de um projeto novo, sem domínios), o primeiro vai antes do
152
+ // primeiro `export ... from` que o arquivo já tem, ou, se não houver, depois do último import
153
+ const firstExport = index.getExportDeclarations().find((item) => item.hasModuleSpecifier());
154
+ const lastImport = imports[imports.length - 1];
155
+ let exportEdit;
156
+ if (reExports.length > 0) {
157
+ exportEdit = insertSorted(reExports, specifier, exportLine, undefined, where);
158
+ }
159
+ else if (firstExport) {
160
+ exportEdit = {
161
+ pos: firstExport.getStart(),
162
+ end: firstExport.getStart(),
163
+ text: `${exportLine}\n`,
164
+ };
165
+ }
166
+ else if (lastImport) {
167
+ exportEdit = { pos: lastImport.getEnd(), end: lastImport.getEnd(), text: `\n\n${exportLine}` };
168
+ }
169
+ else {
170
+ throw new UsageError(`não achei onde acrescentar '${specifier}' em ${where}.`);
171
+ }
172
+ const importEdit = insertSorted(relativeImports, specifier, importLine, lastImport, where);
173
+ // Duas inserções na mesma posição (as duas depois do último import) viram uma só, na ordem
174
+ const sameSpot = importEdit.pos === exportEdit.pos;
175
+ // As posições vêm da árvore de antes de qualquer edição
176
+ applyEdits(index, [
177
+ ...(sameSpot
178
+ ? [{ ...importEdit, text: importEdit.text + exportEdit.text }]
179
+ : [importEdit, exportEdit]),
180
+ factoryEdit,
181
+ ]);
182
+ }
183
+ /** O repositório de um domínio novo: a pasta, a fábrica e a chave saem do nome do domínio. */
184
+ export function registerRepository(plan, to) {
185
+ registerRepositoryEntry(plan, {
186
+ directory: to.plural.kebab,
187
+ factory: `create${to.plural.pascal}Repository`,
188
+ key: to.plural.camel,
189
+ });
190
+ }
191
+ /** Se `src/queries/index.ts` já reexporta o módulo (`export { ... } from './<módulo>'`). */
192
+ export function isQueriesRegistered(plan, module) {
193
+ const index = indexSource(plan, path.join(plan.project.src, 'queries', 'index.ts'));
194
+ return index
195
+ .getExportDeclarations()
196
+ .some((declaration) => declaration.hasModuleSpecifier() && specifierOf(declaration) === `./${module}`);
197
+ }
198
+ /**
199
+ * O `export { <nomes> } from './<módulo>'` em `src/queries/index.ts`, na posição alfabética pelo
200
+ * nome do arquivo, no formato das linhas que já existem.
201
+ */
202
+ export function registerQueriesEntry(plan, entry) {
203
+ const file = path.join(plan.project.src, 'queries', 'index.ts');
204
+ const where = display(plan, file);
205
+ const index = indexSource(plan, file);
206
+ const specifier = `./${entry.module}`;
207
+ const exports = index
208
+ .getExportDeclarations()
209
+ .filter((declaration) => declaration.hasModuleSpecifier());
210
+ if (exports.some((declaration) => specifierOf(declaration) === specifier)) {
211
+ throw new UsageError(`${where} já exporta '${specifier}'.`);
212
+ }
213
+ const { quote, semicolon } = styleOf(exports[0]);
214
+ const line = `export { ${entry.exports.join(', ')} } from ${quote}${specifier}${quote}${semicolon}`;
215
+ // Sem nenhum export (o índice de um projeto novo), o primeiro vai no fim do arquivo
216
+ applyEdits(index, [
217
+ exports.length > 0
218
+ ? insertSorted(exports, specifier, line, undefined, where)
219
+ : appendLine(index, line),
220
+ ]);
221
+ }
222
+ /**
223
+ * O `export { <entidade>Keys, <entidade>Queries } from './<dominio>'` em `src/queries/index.ts`,
224
+ * na posição alfabética pelo nome do arquivo, no formato das linhas que já existem.
225
+ */
226
+ export function registerQueries(plan, to) {
227
+ registerQueriesEntry(plan, {
228
+ module: to.plural.kebab,
229
+ exports: [`${to.singular.camel}Keys`, `${to.singular.camel}Queries`],
230
+ });
231
+ }
232
+ /** As três costuras de um domínio novo: `schemas`, `repositories` e `queries`. */
233
+ export function registerDomain(plan, to) {
234
+ registerSchema(plan, to);
235
+ registerRepository(plan, to);
236
+ registerQueries(plan, to);
237
+ }
@@ -0,0 +1,11 @@
1
+ import type { ChangePlan } from './plan.js';
2
+ /**
3
+ * Registra no `index.ts` de cada idioma do projeto um namespace cujo JSON já está (ou vai estar,
4
+ * pelo plano) em `src/messages/<idioma>/<file>.json`: o import e a chave de `export default`,
5
+ * cada um na posição alfabética (antes do primeiro que vem depois dele; no fim, se nenhum vem).
6
+ * `camel` é o namespace: `produtos`. O namespace que o índice já registra com o mesmo arquivo
7
+ * fica como está, o que deixa o registro repetível. Registrado com outro arquivo (`error404`
8
+ * para `error-404.json`, ou um `import` do produto com o mesmo nome local): `UsageError`, sem
9
+ * escrever nada.
10
+ */
11
+ export declare function registerMessageNamespace(plan: ChangePlan, file: string, camel: string): void;
@@ -0,0 +1,112 @@
1
+ import path from 'node:path';
2
+ import { Node, } from 'ts-morph';
3
+ import { UsageError } from "../errors.js";
4
+ import { afterComma, applyEdits, indentOf } from "./edit.js";
5
+ import { messageLanguages } from "./messages.js";
6
+ /** O nome do arquivo de um import de JSON: `./products-list.json` vira `products-list`. */
7
+ function importedFile(declaration) {
8
+ return path.basename(declaration.getModuleSpecifierValue(), '.json');
9
+ }
10
+ /**
11
+ * A edição que acrescenta o import do JSON na posição alfabética, pelo nome do arquivo. Num índice
12
+ * sem nenhum import (o de um projeto novo, só com o `export default {}`), o primeiro import entra
13
+ * logo antes do `export default`, e um comentário que o preceda continua no alto do arquivo.
14
+ */
15
+ function importEdit(index, file, camel) {
16
+ const imports = index.getImportDeclarations();
17
+ const last = imports[imports.length - 1];
18
+ if (!last) {
19
+ const exported = index.getExportAssignment((assignment) => !assignment.isExportEquals());
20
+ if (!exported) {
21
+ throw new UsageError(`'${index.getFilePath()}' não tem um 'export default { ... }' com os namespaces.`);
22
+ }
23
+ return {
24
+ pos: exported.getStart(),
25
+ end: exported.getStart(),
26
+ text: `import ${camel} from './${file}.json'\n\n`,
27
+ };
28
+ }
29
+ const quote = last.getModuleSpecifier().getText().charAt(0);
30
+ const semicolon = last.getText().endsWith(';') ? ';' : '';
31
+ const line = `import ${camel} from ${quote}./${file}.json${quote}${semicolon}`;
32
+ const next = imports.find((declaration) => importedFile(declaration) > file);
33
+ if (next)
34
+ return { pos: next.getStart(), end: next.getStart(), text: `${line}\n` };
35
+ return { pos: last.getEnd(), end: last.getEnd(), text: `\n${line}` };
36
+ }
37
+ /** O objeto do `export default { ... }` do índice de mensagens. */
38
+ function messagesObject(index) {
39
+ const expression = index
40
+ .getExportAssignment((assignment) => !assignment.isExportEquals())
41
+ ?.getExpression();
42
+ if (!expression || !Node.isObjectLiteralExpression(expression)) {
43
+ throw new UsageError(`'${index.getFilePath()}' não tem um 'export default { ... }' com os namespaces.`);
44
+ }
45
+ return expression;
46
+ }
47
+ /** A edição que acrescenta a chave do namespace no objeto, na posição alfabética. */
48
+ function keyEdit(index, camel) {
49
+ const object = messagesObject(index);
50
+ const properties = object.getProperties();
51
+ const last = properties[properties.length - 1];
52
+ const indent = last ? indentOf(index.getFullText(), last.getStart()) : ' ';
53
+ const next = properties.find((property) => Node.isShorthandPropertyAssignment(property) && property.getName() > camel);
54
+ if (next)
55
+ return { pos: next.getStart(), end: next.getStart(), text: `${camel},\n${indent}` };
56
+ if (!last)
57
+ return {
58
+ pos: object.getStart() + 1,
59
+ end: object.getStart() + 1,
60
+ text: `\n${indent}${camel},\n`,
61
+ };
62
+ const { end, hasComma } = afterComma(index.getFullText(), last.getEnd());
63
+ return { pos: end, end, text: `${hasComma ? '' : ','}\n${indent}${camel}${hasComma ? ',' : ''}` };
64
+ }
65
+ /**
66
+ * Os namespaces que o índice já registra, com o arquivo de cada um quando é um import: as chaves
67
+ * do `export default { ... }` e os nomes locais dos imports de JSON.
68
+ */
69
+ function registeredNamespaces(index) {
70
+ const namespaces = new Map();
71
+ for (const declaration of index.getImportDeclarations()) {
72
+ const local = declaration.getDefaultImport()?.getText();
73
+ if (local !== undefined)
74
+ namespaces.set(local, importedFile(declaration));
75
+ }
76
+ for (const property of messagesObject(index).getProperties()) {
77
+ if (Node.isShorthandPropertyAssignment(property) || Node.isPropertyAssignment(property)) {
78
+ const key = property.getName();
79
+ if (!namespaces.has(key))
80
+ namespaces.set(key, undefined);
81
+ }
82
+ }
83
+ return namespaces;
84
+ }
85
+ /**
86
+ * Acrescenta o import e a chave do namespace no `index.ts` do idioma, cada um na posição
87
+ * alfabética. As duas posições vêm da árvore de antes de qualquer edição.
88
+ */
89
+ function addToIndex(index, file, camel) {
90
+ applyEdits(index, [importEdit(index, file, camel), keyEdit(index, camel)]);
91
+ }
92
+ /**
93
+ * Registra no `index.ts` de cada idioma do projeto um namespace cujo JSON já está (ou vai estar,
94
+ * pelo plano) em `src/messages/<idioma>/<file>.json`: o import e a chave de `export default`,
95
+ * cada um na posição alfabética (antes do primeiro que vem depois dele; no fim, se nenhum vem).
96
+ * `camel` é o namespace: `produtos`. O namespace que o índice já registra com o mesmo arquivo
97
+ * fica como está, o que deixa o registro repetível. Registrado com outro arquivo (`error404`
98
+ * para `error-404.json`, ou um `import` do produto com o mesmo nome local): `UsageError`, sem
99
+ * escrever nada.
100
+ */
101
+ export function registerMessageNamespace(plan, file, camel) {
102
+ for (const language of messageLanguages(plan.project)) {
103
+ const index = plan.source(path.join(plan.project.messages, language, 'index.ts'));
104
+ const registered = registeredNamespaces(index);
105
+ if (registered.has(camel)) {
106
+ if (registered.get(camel) === file)
107
+ continue;
108
+ throw new UsageError(`src/messages/${language}/index.ts já registra o namespace '${camel}' com outro arquivo (${registered.get(camel) ?? 'sem import de JSON'}): o novo é '${file}.json' (o hífen e os números não mudam o nome em camelCase).`);
109
+ }
110
+ addToIndex(index, file, camel);
111
+ }
112
+ }
@@ -0,0 +1,25 @@
1
+ import { Node, type JsxElement, type JsxSelfClosingElement } from 'ts-morph';
2
+ import { type TextLiteral } from './edit.js';
3
+ /** Um `<Route>` do `App.tsx`: com filhos ou autofechado. */
4
+ export type RouteElement = JsxElement | JsxSelfClosingElement;
5
+ /** O nome da tag de um elemento JSX. */
6
+ export declare function tagNameOf(element: RouteElement): string;
7
+ /** Se o nó é um elemento `<Route>`. */
8
+ export declare function isRouteElement(node: Node): node is RouteElement;
9
+ /** Todos os `<Route>` de um arquivo, em qualquer lugar da árvore, na ordem do arquivo. */
10
+ export declare function routeElements(root: Node): RouteElement[];
11
+ /** Se o `<Route>` tem o atributo `nest`: as rotas de dentro dele são relativas ao `path` dele. */
12
+ export declare function isNestRoute(element: RouteElement): boolean;
13
+ /** O literal do atributo `path` de um `<Route>`: `path="/x"` ou `path={'/x'}`. */
14
+ export declare function pathLiteral(element: RouteElement): TextLiteral | undefined;
15
+ /** Se o `<Route>` usa o identificador (o componente da tela) em algum ponto de dentro dele. */
16
+ export declare function usesIdentifier(element: RouteElement, name: string): boolean;
17
+ /**
18
+ * Se o `path` de um `<Route>` (o padrão do wouter) casa com o endereço dado. O padrão pode ter
19
+ * segmentos com parâmetro (`:id`, `:id?`, `:resto*`, `:resto+`) e curinga (`*`, `*?`). A curinga
20
+ * vale por tudo o que vier depois, inclusive nada: `/inbox/*?` casa com `/inbox`, `/inbox/x` e
21
+ * `/inbox/x/y`, e `/inbox/*` também casa com `/inbox` (o wouter exige algo depois da barra, mas a
22
+ * rota nova no mesmo trecho ficaria confusa do mesmo jeito, então a checagem é a do lado seguro).
23
+ * O `address` é lido como texto: o `:id` de uma rota nova com parâmetro conta como um segmento.
24
+ */
25
+ export declare function patternMatches(pattern: string, address: string): boolean;
@@ -0,0 +1,72 @@
1
+ import { Node, SyntaxKind } from 'ts-morph';
2
+ import { isTextLiteral } from "./edit.js";
3
+ /** O nome da tag de um elemento JSX. */
4
+ export function tagNameOf(element) {
5
+ return Node.isJsxElement(element)
6
+ ? element.getOpeningElement().getTagNameNode().getText()
7
+ : element.getTagNameNode().getText();
8
+ }
9
+ /** Se o nó é um elemento `<Route>`. */
10
+ export function isRouteElement(node) {
11
+ return ((Node.isJsxElement(node) || Node.isJsxSelfClosingElement(node)) && tagNameOf(node) === 'Route');
12
+ }
13
+ /** Todos os `<Route>` de um arquivo, em qualquer lugar da árvore, na ordem do arquivo. */
14
+ export function routeElements(root) {
15
+ return root.getDescendants().filter(isRouteElement);
16
+ }
17
+ /** Se o `<Route>` tem o atributo `nest`: as rotas de dentro dele são relativas ao `path` dele. */
18
+ export function isNestRoute(element) {
19
+ const attributes = Node.isJsxElement(element)
20
+ ? element.getOpeningElement().getAttributes()
21
+ : element.getAttributes();
22
+ return attributes.some((attribute) => Node.isJsxAttribute(attribute) && attribute.getNameNode().getText() === 'nest');
23
+ }
24
+ /** O literal do atributo `path` de um `<Route>`: `path="/x"` ou `path={'/x'}`. */
25
+ export function pathLiteral(element) {
26
+ const attributes = Node.isJsxElement(element)
27
+ ? element.getOpeningElement().getAttributes()
28
+ : element.getAttributes();
29
+ for (const attribute of attributes) {
30
+ if (!Node.isJsxAttribute(attribute) || attribute.getNameNode().getText() !== 'path')
31
+ continue;
32
+ const initializer = attribute.getInitializer();
33
+ const value = Node.isJsxExpression(initializer) ? initializer.getExpression() : initializer;
34
+ if (isTextLiteral(value))
35
+ return value;
36
+ }
37
+ return undefined;
38
+ }
39
+ /** Se o `<Route>` usa o identificador (o componente da tela) em algum ponto de dentro dele. */
40
+ export function usesIdentifier(element, name) {
41
+ return element.getDescendantsOfKind(SyntaxKind.Identifier).some((id) => id.getText() === name);
42
+ }
43
+ /** Escapa o texto de um segmento fixo para entrar numa expressão regular. */
44
+ function escapeSegment(segment) {
45
+ return segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
46
+ }
47
+ /**
48
+ * Se o `path` de um `<Route>` (o padrão do wouter) casa com o endereço dado. O padrão pode ter
49
+ * segmentos com parâmetro (`:id`, `:id?`, `:resto*`, `:resto+`) e curinga (`*`, `*?`). A curinga
50
+ * vale por tudo o que vier depois, inclusive nada: `/inbox/*?` casa com `/inbox`, `/inbox/x` e
51
+ * `/inbox/x/y`, e `/inbox/*` também casa com `/inbox` (o wouter exige algo depois da barra, mas a
52
+ * rota nova no mesmo trecho ficaria confusa do mesmo jeito, então a checagem é a do lado seguro).
53
+ * O `address` é lido como texto: o `:id` de uma rota nova com parâmetro conta como um segmento.
54
+ */
55
+ export function patternMatches(pattern, address) {
56
+ let source = '';
57
+ for (const segment of pattern.split('/').filter((part) => part !== '')) {
58
+ if (segment === '*' || segment === '*?')
59
+ source += '(?:/.*)?';
60
+ else if (/^:[^/]+\*$/.test(segment))
61
+ source += '(?:/.*)?';
62
+ else if (/^:[^/]+\+$/.test(segment))
63
+ source += '/.+';
64
+ else if (/^:[^/]+\?$/.test(segment))
65
+ source += '(?:/[^/]+)?';
66
+ else if (segment.startsWith(':'))
67
+ source += '/[^/]+';
68
+ else
69
+ source += `/${escapeSegment(segment)}`;
70
+ }
71
+ return new RegExp(`^${source}/?$`).test(address === '' ? '/' : address);
72
+ }
@@ -0,0 +1,16 @@
1
+ import { type Violation } from '@matizze/prumo-rules/check';
2
+ import type { Runtime } from '../runtime.js';
3
+ /** Uma linha por violação: o arquivo, a regra e o que está errado. */
4
+ export declare function formatViolation({ file, rule, message }: Violation): string;
5
+ /**
6
+ * `prumo check`: analisa o projeto e escreve cada violação com o arquivo e a regra. Sai com 0 sem
7
+ * violação, com 1 com violação e com 2 se a raiz não é um projeto (o `findProject` confere): sem
8
+ * essa conferência, a análise de uma pasta errada não acharia nada e sairia verde.
9
+ */
10
+ export declare function createCheckCommand(runtime: Runtime): import("citty").CommandDef<{
11
+ readonly root: {
12
+ readonly type: "string";
13
+ readonly valueHint: "pasta";
14
+ readonly description: "Pasta do projeto, a que tem o src. Padrão: a pasta atual.";
15
+ };
16
+ }>;
@@ -0,0 +1,47 @@
1
+ import { defineCommand } from 'citty';
2
+ import path from 'node:path';
3
+ import { check } from '@matizze/prumo-rules/check';
4
+ import { ExitError } from "../errors.js";
5
+ import { findProject } from "../project.js";
6
+ /** Uma linha por violação: o arquivo, a regra e o que está errado. */
7
+ export function formatViolation({ file, rule, message }) {
8
+ return `${file} [${rule}] ${message}`;
9
+ }
10
+ /**
11
+ * `prumo check`: analisa o projeto e escreve cada violação com o arquivo e a regra. Sai com 0 sem
12
+ * violação, com 1 com violação e com 2 se a raiz não é um projeto (o `findProject` confere): sem
13
+ * essa conferência, a análise de uma pasta errada não acharia nada e sairia verde.
14
+ */
15
+ export function createCheckCommand(runtime) {
16
+ return defineCommand({
17
+ meta: {
18
+ name: 'check',
19
+ description: `Analisa o projeto e lista as violações da arquitetura.
20
+
21
+ Confere as pastas de src/components, o uso de components/shared pelas telas, a estrutura de cada
22
+ tela e os textos completos nos idiomas.
23
+
24
+ Sai com código 1 quando há violação, e com 2 quando o uso está errado ou a pasta do projeto não
25
+ existe ou não tem package.json e src.`,
26
+ },
27
+ args: {
28
+ root: {
29
+ type: 'string',
30
+ valueHint: 'pasta',
31
+ description: 'Pasta do projeto, a que tem o src. Padrão: a pasta atual.',
32
+ },
33
+ },
34
+ run({ args }) {
35
+ const project = findProject(path.resolve(runtime.cwd, args.root ?? '.'));
36
+ const violations = check({ root: project.root });
37
+ if (violations.length === 0) {
38
+ runtime.out('prumo check: nenhuma violação.\n');
39
+ return;
40
+ }
41
+ const lines = violations.map(formatViolation).join('\n');
42
+ const total = violations.length === 1 ? '1 violação' : `${violations.length} violações`;
43
+ runtime.err(`${lines}\n\nprumo check: ${total}.\n`);
44
+ throw new ExitError(1);
45
+ },
46
+ });
47
+ }
@@ -0,0 +1,20 @@
1
+ import { type DoctorSystem, type Finding } from '../doctor/checks.js';
2
+ import type { Runtime } from '../runtime.js';
3
+ /** Uma linha do relatório: o resultado, o que foi conferido e a explicação. */
4
+ export declare function formatFinding({ status, label, message }: Finding): string;
5
+ /** O fim do relatório: a contagem de erros e avisos, ou "tudo certo". */
6
+ export declare function formatSummary(findings: readonly Finding[]): string;
7
+ /** O Node, o pnpm e o disco de verdade. Os testes passam o próprio. */
8
+ export declare function realSystem(): DoctorSystem;
9
+ /**
10
+ * `prumo doctor`: confere o ambiente e o projeto e escreve uma linha por item, com ok, aviso ou
11
+ * erro. Sai com 0 (tudo certo, ou só avisos), com 1 se há erro e com 2 se a raiz não é um
12
+ * projeto. Não escreve nada em disco e não usa a rede.
13
+ */
14
+ export declare function createDoctorCommand(runtime: Runtime, injected?: DoctorSystem): import("citty").CommandDef<{
15
+ readonly root: {
16
+ readonly type: "string";
17
+ readonly valueHint: "pasta";
18
+ readonly description: "Pasta do projeto, a que tem o package.json. Padrão: a pasta atual.";
19
+ };
20
+ }>;
@@ -0,0 +1,104 @@
1
+ import { defineCommand } from 'citty';
2
+ import { spawnSync } from 'node:child_process';
3
+ import { readFileSync, statSync } from 'node:fs';
4
+ import { tmpdir } from 'node:os';
5
+ import path from 'node:path';
6
+ import { runChecks } from "../doctor/checks.js";
7
+ import { ExitError, UsageError } from "../errors.js";
8
+ const STATUS_TEXT = { ok: 'ok ', warn: 'aviso', error: 'erro ' };
9
+ /** Uma linha do relatório: o resultado, o que foi conferido e a explicação. */
10
+ export function formatFinding({ status, label, message }) {
11
+ return `${STATUS_TEXT[status]} ${label}: ${message}`;
12
+ }
13
+ /** O fim do relatório: a contagem de erros e avisos, ou "tudo certo". */
14
+ export function formatSummary(findings) {
15
+ const count = (status) => findings.filter((finding) => finding.status === status).length;
16
+ const errors = count('error');
17
+ const warnings = count('warn');
18
+ if (errors === 0 && warnings === 0)
19
+ return 'prumo doctor: tudo certo.';
20
+ const parts = [
21
+ errors > 0 ? (errors === 1 ? '1 erro' : `${errors} erros`) : '',
22
+ warnings > 0 ? (warnings === 1 ? '1 aviso' : `${warnings} avisos`) : '',
23
+ ].filter(Boolean);
24
+ return `prumo doctor: ${parts.join(' e ')}.`;
25
+ }
26
+ /** O pnpm que a pessoa usa. Roda fora do projeto e sem baixar versões, porque o doctor não usa a rede. */
27
+ function pnpmVersion() {
28
+ const result = spawnSync('pnpm', ['--version'], {
29
+ cwd: tmpdir(),
30
+ encoding: 'utf8',
31
+ timeout: 20_000,
32
+ env: {
33
+ ...process.env,
34
+ COREPACK_ENABLE_NETWORK: '0',
35
+ COREPACK_ENABLE_AUTO_PIN: '0',
36
+ npm_config_manage_package_manager_versions: 'false',
37
+ },
38
+ });
39
+ const version = result.stdout?.trim();
40
+ return result.status === 0 && version ? version : undefined;
41
+ }
42
+ function readText(file) {
43
+ try {
44
+ return statSync(file).isFile() ? readFileSync(file, 'utf8') : undefined;
45
+ }
46
+ catch {
47
+ return undefined;
48
+ }
49
+ }
50
+ /** A versão desta CLI: o `package.json` do pacote, que fica duas pastas acima de `src/commands` e de `dist/commands`. */
51
+ function readCliVersion() {
52
+ const manifest = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
53
+ return manifest.version;
54
+ }
55
+ /** O Node, o pnpm e o disco de verdade. Os testes passam o próprio. */
56
+ export function realSystem() {
57
+ return {
58
+ nodeVersion: process.versions.node,
59
+ cliVersion: readCliVersion(),
60
+ pnpmVersion,
61
+ readText,
62
+ env: (name) => process.env[name] || undefined,
63
+ };
64
+ }
65
+ /**
66
+ * `prumo doctor`: confere o ambiente e o projeto e escreve uma linha por item, com ok, aviso ou
67
+ * erro. Sai com 0 (tudo certo, ou só avisos), com 1 se há erro e com 2 se a raiz não é um
68
+ * projeto. Não escreve nada em disco e não usa a rede.
69
+ */
70
+ export function createDoctorCommand(runtime, injected) {
71
+ return defineCommand({
72
+ meta: {
73
+ name: 'doctor',
74
+ description: `Confere o ambiente e o projeto: Node, pnpm, pacotes do Prumo e .mcp.json.
75
+
76
+ Cada item sai numa linha com ok, aviso ou erro: o Node (mínimo 24, e o .nvmrc do projeto), o pnpm
77
+ (contra o packageManager), a versão de cada @matizze/prumo-* instalado contra a faixa que esta CLI
78
+ espera e o .mcp.json (com o servidor prumo, o prumo-mcp, que dá ao agente as ferramentas do Prumo).
79
+ Se o .npmrc ainda manda o escopo @matizze para o GitHub Packages, avisa que os pacotes agora estão
80
+ no npm público e que a linha pode sair (nunca lê nem mostra token).
81
+
82
+ Sai com 0 sem erro (avisos não falham), com 1 com erro e com 2 se a pasta não é um projeto. Não
83
+ escreve nada e não usa a rede.`,
84
+ },
85
+ args: {
86
+ root: {
87
+ type: 'string',
88
+ valueHint: 'pasta',
89
+ description: 'Pasta do projeto, a que tem o package.json. Padrão: a pasta atual.',
90
+ },
91
+ },
92
+ run({ args }) {
93
+ const system = injected ?? realSystem();
94
+ const root = path.resolve(runtime.cwd, args.root ?? '.');
95
+ if (system.readText(path.join(root, 'package.json')) === undefined) {
96
+ throw new UsageError(`a pasta '${root}' não tem package.json: aponte --root para a raiz do projeto.`);
97
+ }
98
+ const findings = runChecks({ root, system });
99
+ runtime.out(`${findings.map(formatFinding).join('\n')}\n\n${formatSummary(findings)}\n`);
100
+ if (findings.some((finding) => finding.status === 'error'))
101
+ throw new ExitError(1);
102
+ },
103
+ });
104
+ }