forjajs 1.3.2 → 1.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/CHANGELOG.md +52 -0
- package/README.en.md +1 -0
- package/README.md +10 -4
- package/boilerplates/06-clean-arch/WHEN-CLEAN-WHEN-LEAN.md +37 -8
- package/dist/lib/code-context.d.ts +41 -0
- package/dist/lib/code-context.js +108 -0
- package/dist/lib/core/doc-graph.d.ts +13 -0
- package/dist/lib/core/doc-graph.js +47 -0
- package/dist/lib/core/health.js +29 -1
- package/dist/lib/core/project-smoke.d.ts +46 -0
- package/dist/lib/core/project-smoke.js +248 -0
- package/dist/lib/core/registry.d.ts +25 -0
- package/dist/lib/core/registry.js +25 -0
- package/dist/lib/core/release.d.ts +25 -0
- package/dist/lib/generators/memory-generator.d.ts +1 -0
- package/dist/lib/generators/memory-generator.js +44 -0
- package/dist/lib/generators/readme-generator.js +1 -0
- package/dist/lib/memory-audit.d.ts +31 -0
- package/dist/lib/memory-audit.js +81 -0
- package/dist/lib/project-upgrade.d.ts +28 -0
- package/dist/lib/project-upgrade.js +74 -0
- package/dist/scripts/code-context.d.ts +12 -0
- package/dist/scripts/code-context.js +73 -0
- package/dist/scripts/memory-audit.d.ts +11 -0
- package/dist/scripts/memory-audit.js +49 -0
- package/dist/scripts/project-smoke.d.ts +14 -0
- package/dist/scripts/project-smoke.js +44 -0
- package/dist/scripts/project-upgrade.d.ts +11 -0
- package/dist/scripts/project-upgrade.js +61 -0
- package/dist/scripts/token-economy.d.ts +20 -0
- package/dist/scripts/token-economy.js +140 -0
- package/memory/90-decisions/0025-coerencia-da-documentacao.md +4 -0
- package/memory/90-decisions/0026-migracao-typescript-runtime-duplo.md +66 -0
- package/memory/90-decisions/0027-clean-arch-calibrada.md +34 -3
- package/memory/90-decisions/0029-gate-do-projeto-gerado.md +59 -0
- package/memory/90-decisions/0030-projeto-gerado-herda-os-gates.md +53 -0
- package/package.json +1 -1
- package/specs/code-context/spec.md +56 -0
- package/specs/memory-audit/spec.md +54 -0
- package/specs/project-smoke/spec.md +96 -0
- package/specs/project-upgrade/spec.md +58 -0
|
@@ -0,0 +1,74 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* lib/project-upgrade.ts — a metade que falta do scaffolder (SPEC-018).
|
|
3
|
+
*
|
|
4
|
+
* O framework GERA projetos, mas nunca soube ATUALIZAR um projeto já gerado quando ele evolui: uma
|
|
5
|
+
* memória nova (`70-summaries/`), um agent novo, um config multi-IA novo. Quem gerou na v1.2 ficava
|
|
6
|
+
* preso na v1.2. Aqui a regra é simples e segura: **aditivo, nunca sobrescreve.** O upgrade só traz
|
|
7
|
+
* peças de scaffold que FALTAM no projeto; um arquivo que já existe pode ter edição do usuário, e o
|
|
8
|
+
* código do usuário é intocável.
|
|
9
|
+
*/
|
|
10
|
+
import fs from 'node:fs';
|
|
11
|
+
import path from 'node:path';
|
|
12
|
+
const defaultEnv = { fs };
|
|
13
|
+
/** Dirs que são runtime/build/deps — não são scaffold a copiar. */
|
|
14
|
+
const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', '.memory', '.context']);
|
|
15
|
+
/** Todos os arquivos (rel) sob um root, menos os SKIP_DIRS. */
|
|
16
|
+
export function listFiles(root, env = defaultEnv) {
|
|
17
|
+
const out = [];
|
|
18
|
+
const walk = (dir) => {
|
|
19
|
+
let entries;
|
|
20
|
+
try {
|
|
21
|
+
entries = env.fs.readdirSync(dir);
|
|
22
|
+
}
|
|
23
|
+
catch {
|
|
24
|
+
return;
|
|
25
|
+
}
|
|
26
|
+
for (const e of entries) {
|
|
27
|
+
if (SKIP_DIRS.has(e))
|
|
28
|
+
continue;
|
|
29
|
+
const p = path.join(dir, e);
|
|
30
|
+
let st;
|
|
31
|
+
try {
|
|
32
|
+
st = env.fs.statSync(p);
|
|
33
|
+
}
|
|
34
|
+
catch {
|
|
35
|
+
continue;
|
|
36
|
+
}
|
|
37
|
+
if (st.isDirectory())
|
|
38
|
+
walk(p);
|
|
39
|
+
else
|
|
40
|
+
out.push(path.relative(root, p));
|
|
41
|
+
}
|
|
42
|
+
};
|
|
43
|
+
walk(root);
|
|
44
|
+
return out.sort();
|
|
45
|
+
}
|
|
46
|
+
/**
|
|
47
|
+
* Planeja o upgrade: o que o scaffold fresco tem que o projeto-alvo não tem. **Só adições** — nunca
|
|
48
|
+
* lista sobrescritas, porque um arquivo existente é território do usuário.
|
|
49
|
+
*/
|
|
50
|
+
export function planUpgrade(freshRoot, targetRoot, env = defaultEnv) {
|
|
51
|
+
const fresh = listFiles(freshRoot, env);
|
|
52
|
+
const newFiles = [];
|
|
53
|
+
let existing = 0;
|
|
54
|
+
for (const rel of fresh) {
|
|
55
|
+
if (env.fs.existsSync(path.join(targetRoot, rel)))
|
|
56
|
+
existing += 1;
|
|
57
|
+
else
|
|
58
|
+
newFiles.push(rel);
|
|
59
|
+
}
|
|
60
|
+
return { newFiles, existing };
|
|
61
|
+
}
|
|
62
|
+
/** Aplica o plano: copia as peças novas para o alvo, criando diretórios. Nunca sobrescreve. */
|
|
63
|
+
export function applyUpgrade(freshRoot, targetRoot, plan, env = defaultEnv) {
|
|
64
|
+
const applied = [];
|
|
65
|
+
for (const rel of plan.newFiles) {
|
|
66
|
+
const dst = path.join(targetRoot, rel);
|
|
67
|
+
if (env.fs.existsSync(dst))
|
|
68
|
+
continue; // paranoia: nunca sobrescreve
|
|
69
|
+
env.fs.mkdirSync(path.dirname(dst), { recursive: true });
|
|
70
|
+
env.fs.copyFileSync(path.join(freshRoot, rel), dst);
|
|
71
|
+
applied.push(rel);
|
|
72
|
+
}
|
|
73
|
+
return applied;
|
|
74
|
+
}
|
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
/**
|
|
3
|
+
* code:context — entrega o pacote de contexto mínimo de um domínio (SPEC-016, ADR-0009).
|
|
4
|
+
*
|
|
5
|
+
* forja code:context <domínio> só o mapa (context.md) — o contexto barato
|
|
6
|
+
* forja code:context <domínio> --code + o código da fatia (para editar)
|
|
7
|
+
* forja code:context <domínio> --project <path> aponta para outro projeto
|
|
8
|
+
*
|
|
9
|
+
* O −61% do `token:economy` virado ferramenta: o mapa que substitui a exploração, pronto para colar.
|
|
10
|
+
* Para o blast radius de um símbolo específico, componha com `forja code:impact <símbolo>`.
|
|
11
|
+
*/
|
|
12
|
+
export {};
|
|
@@ -0,0 +1,73 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
/**
|
|
3
|
+
* code:context — entrega o pacote de contexto mínimo de um domínio (SPEC-016, ADR-0009).
|
|
4
|
+
*
|
|
5
|
+
* forja code:context <domínio> só o mapa (context.md) — o contexto barato
|
|
6
|
+
* forja code:context <domínio> --code + o código da fatia (para editar)
|
|
7
|
+
* forja code:context <domínio> --project <path> aponta para outro projeto
|
|
8
|
+
*
|
|
9
|
+
* O −61% do `token:economy` virado ferramenta: o mapa que substitui a exploração, pronto para colar.
|
|
10
|
+
* Para o blast radius de um símbolo específico, componha com `forja code:impact <símbolo>`.
|
|
11
|
+
*/
|
|
12
|
+
import path from 'node:path';
|
|
13
|
+
import { buildContextPack, domainsOf } from "../lib/code-context.js";
|
|
14
|
+
function arg(name) {
|
|
15
|
+
const i = process.argv.indexOf(name);
|
|
16
|
+
return i >= 0 ? process.argv[i + 1] ?? null : null;
|
|
17
|
+
}
|
|
18
|
+
function main() {
|
|
19
|
+
// Positionals = tudo que não é flag nem valor de flag. `--project` consome o próximo arg.
|
|
20
|
+
const argv = process.argv.slice(2);
|
|
21
|
+
const positional = [];
|
|
22
|
+
for (let i = 0; i < argv.length; i += 1) {
|
|
23
|
+
if (argv[i] === '--project') {
|
|
24
|
+
i += 1; // pula o valor
|
|
25
|
+
continue;
|
|
26
|
+
}
|
|
27
|
+
if (argv[i].startsWith('--'))
|
|
28
|
+
continue;
|
|
29
|
+
positional.push(argv[i]);
|
|
30
|
+
}
|
|
31
|
+
const domain = positional[0];
|
|
32
|
+
const projectRoot = path.resolve(arg('--project') || process.cwd());
|
|
33
|
+
const includeCode = process.argv.includes('--code');
|
|
34
|
+
const available = domainsOf(projectRoot);
|
|
35
|
+
if (!domain) {
|
|
36
|
+
if (!available.length) {
|
|
37
|
+
console.error(`Nenhum domínio em ${path.join(projectRoot, 'memory/30-domains')}.`);
|
|
38
|
+
console.error('Rode dentro de um projeto gerado, ou aponte com --project <path>.');
|
|
39
|
+
process.exit(1);
|
|
40
|
+
}
|
|
41
|
+
console.log('Uso: forja code:context <domínio> [--code] [--project <path>]\n');
|
|
42
|
+
console.log(`Domínios disponíveis: ${available.join(', ')}`);
|
|
43
|
+
return;
|
|
44
|
+
}
|
|
45
|
+
const pack = buildContextPack({ projectRoot, domain, includeCode });
|
|
46
|
+
if (!pack.found) {
|
|
47
|
+
console.error(`Domínio "${domain}" não tem context.md em ${projectRoot}.`);
|
|
48
|
+
if (available.length)
|
|
49
|
+
console.error(`Disponíveis: ${available.join(', ')}`);
|
|
50
|
+
process.exit(1);
|
|
51
|
+
}
|
|
52
|
+
// O pacote em si — pronto para colar no contexto de um agente.
|
|
53
|
+
console.log(`# Contexto do domínio: ${domain}\n`);
|
|
54
|
+
console.log(`> Mapa: ${pack.mapPath} (${pack.mapTokens} tokens)\n`);
|
|
55
|
+
console.log(pack.map);
|
|
56
|
+
if (includeCode) {
|
|
57
|
+
for (const c of pack.code) {
|
|
58
|
+
console.log(`\n\n---\n\n## ${c.path} (${c.tokens} tokens)\n`);
|
|
59
|
+
console.log('```ts');
|
|
60
|
+
console.log(c.content);
|
|
61
|
+
console.log('```');
|
|
62
|
+
}
|
|
63
|
+
}
|
|
64
|
+
// Rodapé de economia — o custo à mostra (dogfood do token:economy).
|
|
65
|
+
console.error(''); // separa do stdout colável
|
|
66
|
+
if (includeCode) {
|
|
67
|
+
console.error(`— pacote completo: ${pack.totalTokens} tokens (mapa ${pack.mapTokens} + código ${pack.codeTokens}, ${pack.code.length} arquivos).`);
|
|
68
|
+
}
|
|
69
|
+
else {
|
|
70
|
+
console.error(`— só o mapa: ${pack.mapTokens} tokens. Para editar, adicione o código com --code, ou o blast radius com \`forja code:impact <símbolo>\`.`);
|
|
71
|
+
}
|
|
72
|
+
}
|
|
73
|
+
main();
|
|
@@ -0,0 +1,11 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
/**
|
|
3
|
+
* memory:audit — os mapas de memória não mentem sobre o código (SPEC-017, ADR-0009).
|
|
4
|
+
*
|
|
5
|
+
* forja memory:audit audita os mapas do projeto no cwd
|
|
6
|
+
* forja memory:audit --project <path> aponta para outro projeto
|
|
7
|
+
*
|
|
8
|
+
* Para cada `memory/30-domains/<d>/context.md`, confere que todo path de código citado existe.
|
|
9
|
+
* Um mapa que aponta para arquivo renomeado/deletado engana com confiança — este comando reprova.
|
|
10
|
+
*/
|
|
11
|
+
export {};
|
|
@@ -0,0 +1,49 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
/**
|
|
3
|
+
* memory:audit — os mapas de memória não mentem sobre o código (SPEC-017, ADR-0009).
|
|
4
|
+
*
|
|
5
|
+
* forja memory:audit audita os mapas do projeto no cwd
|
|
6
|
+
* forja memory:audit --project <path> aponta para outro projeto
|
|
7
|
+
*
|
|
8
|
+
* Para cada `memory/30-domains/<d>/context.md`, confere que todo path de código citado existe.
|
|
9
|
+
* Um mapa que aponta para arquivo renomeado/deletado engana com confiança — este comando reprova.
|
|
10
|
+
*/
|
|
11
|
+
import path from 'node:path';
|
|
12
|
+
import { auditMemoryMaps, modulesWithoutMap } from "../lib/memory-audit.js";
|
|
13
|
+
function main() {
|
|
14
|
+
const i = process.argv.indexOf('--project');
|
|
15
|
+
const projectRoot = path.resolve(i >= 0 ? process.argv[i + 1] : process.cwd());
|
|
16
|
+
const audits = auditMemoryMaps(projectRoot);
|
|
17
|
+
if (!audits.length) {
|
|
18
|
+
console.log(`Nenhum mapa de domínio em ${path.join(projectRoot, 'memory/30-domains')}.`);
|
|
19
|
+
console.log('Rode dentro de um projeto gerado, ou aponte com --project <path>.');
|
|
20
|
+
return;
|
|
21
|
+
}
|
|
22
|
+
let totalDangling = 0;
|
|
23
|
+
for (const a of audits) {
|
|
24
|
+
if (a.dangling.length) {
|
|
25
|
+
totalDangling += a.dangling.length;
|
|
26
|
+
console.log(`✗ ${a.domain} (${a.mapPath}) — ${a.dangling.length}/${a.refs} referência(s) pendurada(s):`);
|
|
27
|
+
for (const d of a.dangling)
|
|
28
|
+
console.log(` ${d} — o mapa aponta, o arquivo não existe`);
|
|
29
|
+
}
|
|
30
|
+
else {
|
|
31
|
+
console.log(`✓ ${a.domain} — ${a.refs} referência(s), todas resolvem`);
|
|
32
|
+
}
|
|
33
|
+
}
|
|
34
|
+
// Direção reversa: módulo de código sem mapa. Aviso, não falha — é economia perdida, não mentira.
|
|
35
|
+
const semMapa = modulesWithoutMap(projectRoot);
|
|
36
|
+
if (semMapa.length) {
|
|
37
|
+
console.log('');
|
|
38
|
+
for (const m of semMapa) {
|
|
39
|
+
console.log(`⚠ módulo "${m}" não tem context.md — a economia de token da memória está perdida para ele`);
|
|
40
|
+
}
|
|
41
|
+
console.log(` crie memory/30-domains/${semMapa[0]}/context.md (o mapa do domínio).`);
|
|
42
|
+
}
|
|
43
|
+
if (totalDangling) {
|
|
44
|
+
console.log(`\nREPROVADO — ${totalDangling} referência(s) pendurada(s). O mapa mente; corrija o context.md ou o path.`);
|
|
45
|
+
process.exit(1);
|
|
46
|
+
}
|
|
47
|
+
console.log(`\nAPROVADO — todo mapa aponta para código que existe${semMapa.length ? ` (${semMapa.length} módulo(s) ainda sem mapa — veja acima)` : ''}.`);
|
|
48
|
+
}
|
|
49
|
+
main();
|
|
@@ -0,0 +1,14 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
/**
|
|
3
|
+
* project-smoke — o gate do projeto gerado (SPEC-015).
|
|
4
|
+
*
|
|
5
|
+
* Responde a uma pergunta com evidência: **o que `forja project:new` gera é coerente?**
|
|
6
|
+
* Gera um projeto num diretório isolado e reprova se um template vazou, um `package.json` não
|
|
7
|
+
* parseia, a estrutura está incompleta — ou, no tier `--full`, se o backend não buildar.
|
|
8
|
+
*
|
|
9
|
+
* forja project:smoke tier barato (placeholders, JSON, estrutura) — roda no CI
|
|
10
|
+
* forja project:smoke -- --full + npm install && npm run build do backend gerado (lento, rede)
|
|
11
|
+
*
|
|
12
|
+
* É o `release:check` da saída do gerador, um nível acima do tarball.
|
|
13
|
+
*/
|
|
14
|
+
export {};
|
|
@@ -0,0 +1,44 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
/**
|
|
3
|
+
* project-smoke — o gate do projeto gerado (SPEC-015).
|
|
4
|
+
*
|
|
5
|
+
* Responde a uma pergunta com evidência: **o que `forja project:new` gera é coerente?**
|
|
6
|
+
* Gera um projeto num diretório isolado e reprova se um template vazou, um `package.json` não
|
|
7
|
+
* parseia, a estrutura está incompleta — ou, no tier `--full`, se o backend não buildar.
|
|
8
|
+
*
|
|
9
|
+
* forja project:smoke tier barato (placeholders, JSON, estrutura) — roda no CI
|
|
10
|
+
* forja project:smoke -- --full + npm install && npm run build do backend gerado (lento, rede)
|
|
11
|
+
*
|
|
12
|
+
* É o `release:check` da saída do gerador, um nível acima do tarball.
|
|
13
|
+
*/
|
|
14
|
+
import { runProjectSmoke, worstStatus } from "../lib/core/project-smoke.js";
|
|
15
|
+
const TAG = { ok: 'OK ', warn: 'AVISO', fail: 'FALHA', skipped: '— ' };
|
|
16
|
+
async function main() {
|
|
17
|
+
const full = process.argv.includes('--full');
|
|
18
|
+
console.log(`\nForja project smoke${full ? ' (tier --full)' : ''}\n`);
|
|
19
|
+
console.log(`Gerando um projeto num diretório isolado${full ? ' e buildando o backend — isto leva minutos' : ''}.\n`);
|
|
20
|
+
const results = await runProjectSmoke({ full });
|
|
21
|
+
for (const r of results) {
|
|
22
|
+
console.log(`${TAG[r.status]} ${r.id.padEnd(16)} ${r.detail}`);
|
|
23
|
+
if (r.fix)
|
|
24
|
+
console.log(` corrigir: ${r.fix}`);
|
|
25
|
+
console.log('');
|
|
26
|
+
}
|
|
27
|
+
const verdict = worstStatus(results);
|
|
28
|
+
if (verdict === 'fail') {
|
|
29
|
+
const raiz = results.filter((r) => r.status === 'fail' && r.severity === 'critical');
|
|
30
|
+
console.log(`REPROVADO — ${raiz.length} falha(s) crítica(s). O gerador está entregando um projeto quebrado.`);
|
|
31
|
+
for (const r of raiz)
|
|
32
|
+
console.log(` ${r.id}: ${r.fix || 'sem correção automática'}`);
|
|
33
|
+
process.exit(1);
|
|
34
|
+
}
|
|
35
|
+
if (verdict === 'warn') {
|
|
36
|
+
console.log('Aprovado com ressalvas.');
|
|
37
|
+
return;
|
|
38
|
+
}
|
|
39
|
+
console.log(full ? 'APROVADO — o projeto gerado instala e compila.' : 'APROVADO — o projeto gerado é coerente. Para provar o build, rode com --full.');
|
|
40
|
+
}
|
|
41
|
+
main().catch((err) => {
|
|
42
|
+
console.error(`\nproject-smoke falhou: ${err.message}`);
|
|
43
|
+
process.exit(1);
|
|
44
|
+
});
|
|
@@ -0,0 +1,11 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
/**
|
|
3
|
+
* project:upgrade — traz peças novas de scaffold para um projeto já gerado (SPEC-018).
|
|
4
|
+
*
|
|
5
|
+
* forja project:upgrade dry-run: lista o que falta (cwd)
|
|
6
|
+
* forja project:upgrade --apply copia as peças novas
|
|
7
|
+
* forja project:upgrade --project <path> aponta para outro projeto
|
|
8
|
+
*
|
|
9
|
+
* Aditivo, nunca sobrescreve: só traz arquivos que o projeto não tem. O código do usuário é intocável.
|
|
10
|
+
*/
|
|
11
|
+
export {};
|
|
@@ -0,0 +1,61 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
/**
|
|
3
|
+
* project:upgrade — traz peças novas de scaffold para um projeto já gerado (SPEC-018).
|
|
4
|
+
*
|
|
5
|
+
* forja project:upgrade dry-run: lista o que falta (cwd)
|
|
6
|
+
* forja project:upgrade --apply copia as peças novas
|
|
7
|
+
* forja project:upgrade --project <path> aponta para outro projeto
|
|
8
|
+
*
|
|
9
|
+
* Aditivo, nunca sobrescreve: só traz arquivos que o projeto não tem. O código do usuário é intocável.
|
|
10
|
+
*/
|
|
11
|
+
import { execFileSync } from 'node:child_process';
|
|
12
|
+
import fs from 'node:fs';
|
|
13
|
+
import os from 'node:os';
|
|
14
|
+
import path from 'node:path';
|
|
15
|
+
import { fileURLToPath } from 'node:url';
|
|
16
|
+
import { planUpgrade, applyUpgrade } from "../lib/project-upgrade.js";
|
|
17
|
+
const __filename = fileURLToPath(import.meta.url);
|
|
18
|
+
const repoRoot = path.resolve(path.dirname(__filename), '..');
|
|
19
|
+
function main() {
|
|
20
|
+
const i = process.argv.indexOf('--project');
|
|
21
|
+
const target = path.resolve(i >= 0 ? process.argv[i + 1] : process.cwd());
|
|
22
|
+
const apply = process.argv.includes('--apply');
|
|
23
|
+
if (!fs.existsSync(path.join(target, 'AGENTS.md'))) {
|
|
24
|
+
console.error(`${target} não parece um projeto Forja (sem AGENTS.md).`);
|
|
25
|
+
console.error('Rode dentro de um projeto gerado, ou aponte com --project <path>.');
|
|
26
|
+
process.exit(1);
|
|
27
|
+
}
|
|
28
|
+
// Gera um scaffold fresco num tmp isolado, com o ambiente limpo (a lição do release:check).
|
|
29
|
+
const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'forja-upgrade-'));
|
|
30
|
+
const fresh = path.join(tmp, 'fresh');
|
|
31
|
+
try {
|
|
32
|
+
const env = { ...process.env };
|
|
33
|
+
delete env.NODE_PATH;
|
|
34
|
+
for (const k of Object.keys(env))
|
|
35
|
+
if (k.startsWith('npm_'))
|
|
36
|
+
delete env[k];
|
|
37
|
+
execFileSync(process.execPath, [path.join(repoRoot, 'bin', 'create-memory-nest-kit.ts'), fresh, '--force'], {
|
|
38
|
+
cwd: tmp,
|
|
39
|
+
env,
|
|
40
|
+
stdio: 'pipe',
|
|
41
|
+
});
|
|
42
|
+
const plan = planUpgrade(fresh, target);
|
|
43
|
+
if (!plan.newFiles.length) {
|
|
44
|
+
console.log(`Projeto já em dia — ${plan.existing} arquivo(s) de scaffold presentes, nenhuma peça nova.`);
|
|
45
|
+
return;
|
|
46
|
+
}
|
|
47
|
+
console.log(`${plan.newFiles.length} peça(s) de scaffold nova(s) que este projeto ainda não tem:\n`);
|
|
48
|
+
for (const rel of plan.newFiles)
|
|
49
|
+
console.log(` + ${rel}`);
|
|
50
|
+
if (!apply) {
|
|
51
|
+
console.log(`\nDry-run. Rode com --apply para copiar. Aditivo: nada existente é sobrescrito.`);
|
|
52
|
+
return;
|
|
53
|
+
}
|
|
54
|
+
const applied = applyUpgrade(fresh, target, plan);
|
|
55
|
+
console.log(`\n✓ ${applied.length} arquivo(s) copiado(s). Revise o diff antes de commitar.`);
|
|
56
|
+
}
|
|
57
|
+
finally {
|
|
58
|
+
fs.rmSync(tmp, { recursive: true, force: true });
|
|
59
|
+
}
|
|
60
|
+
}
|
|
61
|
+
main();
|
|
@@ -0,0 +1,20 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
/**
|
|
3
|
+
* token-economy — mede, não argumenta (fecha a dívida do ADR-0027; ADR-0009 e ADR-0003).
|
|
4
|
+
*
|
|
5
|
+
* Dois eixos, porque a economia de token do Forja tem dois eixos e eles são diferentes:
|
|
6
|
+
*
|
|
7
|
+
* 1. ARQUITETURA (clean vs flat) — camadas custam tokens. Numa feature pequena, o flat é mais
|
|
8
|
+
* barato. É honesto, e desmente a versão ingênua de "Clean Architecture economiza tokens".
|
|
9
|
+
*
|
|
10
|
+
* 2. MEMÓRIA (frio vs quente) — o `context.md` é o mapa. Sem ele, um agente varre o código da
|
|
11
|
+
* fatia para localizar a regra; com ele, vai direto ao agregado. AQUI está a economia real do
|
|
12
|
+
* framework (ADR-0009), e ela COMPÕE: paga-se o scaffold uma vez, e o mapa economiza a cada
|
|
13
|
+
* tarefa futura pela vida do projeto.
|
|
14
|
+
*
|
|
15
|
+
* O `token:economy` sozinho não captura o custo de gerar do zero (isso é custo líquido, único). Ele
|
|
16
|
+
* captura o regime permanente — o projeto já levantado, onde a memória persistente paga de volta.
|
|
17
|
+
*
|
|
18
|
+
* Token ≈ bytes/4 (o mesmo proxy do resto do framework). Não é preciso; é reproduzível e honesto.
|
|
19
|
+
*/
|
|
20
|
+
export {};
|
|
@@ -0,0 +1,140 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
/**
|
|
3
|
+
* token-economy — mede, não argumenta (fecha a dívida do ADR-0027; ADR-0009 e ADR-0003).
|
|
4
|
+
*
|
|
5
|
+
* Dois eixos, porque a economia de token do Forja tem dois eixos e eles são diferentes:
|
|
6
|
+
*
|
|
7
|
+
* 1. ARQUITETURA (clean vs flat) — camadas custam tokens. Numa feature pequena, o flat é mais
|
|
8
|
+
* barato. É honesto, e desmente a versão ingênua de "Clean Architecture economiza tokens".
|
|
9
|
+
*
|
|
10
|
+
* 2. MEMÓRIA (frio vs quente) — o `context.md` é o mapa. Sem ele, um agente varre o código da
|
|
11
|
+
* fatia para localizar a regra; com ele, vai direto ao agregado. AQUI está a economia real do
|
|
12
|
+
* framework (ADR-0009), e ela COMPÕE: paga-se o scaffold uma vez, e o mapa economiza a cada
|
|
13
|
+
* tarefa futura pela vida do projeto.
|
|
14
|
+
*
|
|
15
|
+
* O `token:economy` sozinho não captura o custo de gerar do zero (isso é custo líquido, único). Ele
|
|
16
|
+
* captura o regime permanente — o projeto já levantado, onde a memória persistente paga de volta.
|
|
17
|
+
*
|
|
18
|
+
* Token ≈ bytes/4 (o mesmo proxy do resto do framework). Não é preciso; é reproduzível e honesto.
|
|
19
|
+
*/
|
|
20
|
+
import fs from 'node:fs';
|
|
21
|
+
import path from 'node:path';
|
|
22
|
+
import { fileURLToPath } from 'node:url';
|
|
23
|
+
import { domainsOf, buildContextPack } from "../lib/code-context.js";
|
|
24
|
+
const __filename = fileURLToPath(import.meta.url);
|
|
25
|
+
const root = path.resolve(path.dirname(__filename), '..');
|
|
26
|
+
/**
|
|
27
|
+
* Modo `--project <path>`: mede o eixo memória nos domínios REAIS do usuário, não na fixture. Para
|
|
28
|
+
* cada domínio, o mapa (`context.md`) vs ler todo o código da fatia — o número fica dele.
|
|
29
|
+
*/
|
|
30
|
+
function projectMode(projectRoot) {
|
|
31
|
+
const domains = domainsOf(projectRoot);
|
|
32
|
+
console.log(`\nToken economy — eixo memória nos domínios de ${projectRoot} (ADR-0009)\n`);
|
|
33
|
+
if (!domains.length) {
|
|
34
|
+
console.log(`Nenhum domínio em ${path.join(projectRoot, 'memory/30-domains')}. Rode dentro de um projeto gerado.`);
|
|
35
|
+
return;
|
|
36
|
+
}
|
|
37
|
+
console.log('Para cada domínio: ler o mapa (context.md) vs ler todo o código da fatia.\n');
|
|
38
|
+
const rows = [];
|
|
39
|
+
for (const domain of domains) {
|
|
40
|
+
const pack = buildContextPack({ projectRoot, domain, includeCode: true });
|
|
41
|
+
const economy = pack.codeTokens === 0 ? '—' : `−${Math.round(((pack.codeTokens - pack.mapTokens) / pack.codeTokens) * 100)}%`;
|
|
42
|
+
rows.push({ domínio: domain, mapa_tok: pack.mapTokens, código_tok: pack.codeTokens, mapa_vs_código: economy });
|
|
43
|
+
console.log(`■ ${domain}`);
|
|
44
|
+
console.log(` mapa (context.md): ${String(pack.mapTokens).padStart(5)} tok`);
|
|
45
|
+
console.log(` código da fatia: ${String(pack.codeTokens).padStart(5)} tok (${pack.code.length} arq.)`);
|
|
46
|
+
console.log(` o mapa custa ${economy} do código — é o resumo que substitui a leitura da árvore\n`);
|
|
47
|
+
}
|
|
48
|
+
console.log('O mapa é o resumo do domínio: lê-lo custa uma fração de ler a fatia inteira. Essa é a');
|
|
49
|
+
console.log('economia da memória, medida no SEU projeto. (Sem mapa? rode `forja memory:audit`.)\n');
|
|
50
|
+
if (process.argv.includes('--json'))
|
|
51
|
+
console.log(JSON.stringify(rows, null, 2));
|
|
52
|
+
}
|
|
53
|
+
const CLEAN = 'boilerplates/06-clean-arch/backend/src/modules/orders';
|
|
54
|
+
const CLEAN_CTX = 'boilerplates/06-clean-arch/memory/30-domains/orders/context.md';
|
|
55
|
+
const SHARED = 'boilerplates/06-clean-arch/backend/src/shared/result.ts';
|
|
56
|
+
const FLAT = 'benchmarks/clean-vs-flat/orders-flat';
|
|
57
|
+
/** Todo o código da fatia Orders (clean) — o que se varre "no frio", sem mapa. */
|
|
58
|
+
const CLEAN_CODE = [
|
|
59
|
+
`${CLEAN}/domain/order.entity.ts`,
|
|
60
|
+
`${CLEAN}/domain/order-status.vo.ts`,
|
|
61
|
+
`${CLEAN}/domain/money.vo.ts`,
|
|
62
|
+
`${CLEAN}/domain/order.repository.ts`,
|
|
63
|
+
`${CLEAN}/application/place-order.usecase.ts`,
|
|
64
|
+
`${CLEAN}/application/ship-order.usecase.ts`,
|
|
65
|
+
`${CLEAN}/infrastructure/order.orm-entity.ts`,
|
|
66
|
+
`${CLEAN}/infrastructure/typeorm-order.repository.ts`,
|
|
67
|
+
`${CLEAN}/presentation/orders.controller.ts`,
|
|
68
|
+
`${CLEAN}/presentation/orders.http.dto.ts`,
|
|
69
|
+
`${CLEAN}/orders.module.ts`,
|
|
70
|
+
SHARED,
|
|
71
|
+
];
|
|
72
|
+
const SCENARIOS = [
|
|
73
|
+
{
|
|
74
|
+
axis: 'arquitetura',
|
|
75
|
+
name: 'entender a feature inteira',
|
|
76
|
+
question: 'ler todo o código da fatia para entender o que ela faz',
|
|
77
|
+
a: { label: 'clean', files: CLEAN_CODE },
|
|
78
|
+
b: {
|
|
79
|
+
label: 'flat',
|
|
80
|
+
files: [`${FLAT}/order.entity.ts`, `${FLAT}/orders.service.ts`, `${FLAT}/orders.controller.ts`],
|
|
81
|
+
},
|
|
82
|
+
},
|
|
83
|
+
{
|
|
84
|
+
axis: 'arquitetura',
|
|
85
|
+
name: 'mudar a regra de envio',
|
|
86
|
+
question: 'alterar a invariante "não envia sem pagamento" — o contexto mínimo suficiente',
|
|
87
|
+
a: { label: 'clean', files: [CLEAN_CTX, `${CLEAN}/domain/order.entity.ts`, `${CLEAN}/domain/order-status.vo.ts`] },
|
|
88
|
+
b: { label: 'flat', files: [`${FLAT}/orders.service.ts`] },
|
|
89
|
+
},
|
|
90
|
+
{
|
|
91
|
+
axis: 'memória',
|
|
92
|
+
name: 'trabalhar no domínio — com vs sem o mapa da memória',
|
|
93
|
+
question: 'localizar e mexer na regra numa fatia já existente (ADR-0009) — o regime permanente',
|
|
94
|
+
// Quente: a memória (context.md) aponta o agregado + a máquina de estados. Vai direto.
|
|
95
|
+
a: { label: 'quente (memória)', files: [CLEAN_CTX, `${CLEAN}/domain/order.entity.ts`, `${CLEAN}/domain/order-status.vo.ts`] },
|
|
96
|
+
// Frio: sem mapa, varre o código da fatia para descobrir onde a regra vive.
|
|
97
|
+
b: { label: 'frio (sem memória)', files: CLEAN_CODE },
|
|
98
|
+
},
|
|
99
|
+
];
|
|
100
|
+
const tokensOf = (rel) => {
|
|
101
|
+
try {
|
|
102
|
+
return Math.round(fs.readFileSync(path.join(root, rel), 'utf8').length / 4);
|
|
103
|
+
}
|
|
104
|
+
catch {
|
|
105
|
+
return 0;
|
|
106
|
+
}
|
|
107
|
+
};
|
|
108
|
+
const sum = (files) => files.reduce((acc, f) => acc + tokensOf(f), 0);
|
|
109
|
+
const pct = (a, b) => (b === 0 ? '—' : `${a <= b ? '−' : '+'}${Math.abs(Math.round(((a - b) / b) * 100))}%`);
|
|
110
|
+
// `--project <path>`: mede o eixo memória no projeto real e sai. Sem ele, o benchmark de fixture.
|
|
111
|
+
const projIdx = process.argv.indexOf('--project');
|
|
112
|
+
if (projIdx >= 0) {
|
|
113
|
+
projectMode(path.resolve(process.argv[projIdx + 1] || process.cwd()));
|
|
114
|
+
process.exit(0);
|
|
115
|
+
}
|
|
116
|
+
console.log('\nToken economy — o custo do CONTEXTO por cenário (ADR-0027, ADR-0009)\n');
|
|
117
|
+
console.log('Token ≈ bytes/4. Não mede o custo de gerar do zero (custo único); mede o regime permanente.\n');
|
|
118
|
+
const out = [];
|
|
119
|
+
for (const s of SCENARIOS) {
|
|
120
|
+
const a = sum(s.a.files);
|
|
121
|
+
const b = sum(s.b.files);
|
|
122
|
+
out.push({ eixo: s.axis, cenário: s.name, [s.a.label]: a, [s.b.label]: b, a_vs_b: pct(a, b) });
|
|
123
|
+
console.log(`■ [${s.axis}] ${s.name}`);
|
|
124
|
+
console.log(` ${s.question}`);
|
|
125
|
+
console.log(` ${s.a.label.padEnd(18)} ${String(a).padStart(5)} tok (${s.a.files.length} arq.)`);
|
|
126
|
+
console.log(` ${s.b.label.padEnd(18)} ${String(b).padStart(5)} tok (${s.b.files.length} arq.)`);
|
|
127
|
+
console.log(` ${s.a.label} vs ${s.b.label}: ${pct(a, b)}\n`);
|
|
128
|
+
}
|
|
129
|
+
const arch = out[1]; // mudar a regra, clean vs flat
|
|
130
|
+
const mem = out[2]; // frio vs quente
|
|
131
|
+
console.log('Veredito (derivado dos números):');
|
|
132
|
+
console.log(` • EIXO ARQUITETURA: numa feature pequena, camadas custam MAIS token (${arch.a_vs_b} para`);
|
|
133
|
+
console.log(` a mudança isolada). "Clean Architecture economiza tokens" não se sustenta nessa escala —`);
|
|
134
|
+
console.log(` a justificativa das camadas é isolamento e testabilidade, não token.`);
|
|
135
|
+
console.log(` • EIXO MEMÓRIA: o mapa (context.md) faz o contexto mínimo custar ${mem.a_vs_b} vs varrer`);
|
|
136
|
+
console.log(` a fatia no frio. É AQUI que a economia mora — e ela COMPÕE: o scaffold é custo único,`);
|
|
137
|
+
console.log(` o mapa economiza a cada tarefa futura. Depois do projeto levantado, a memória paga de volta.\n`);
|
|
138
|
+
if (process.argv.includes('--json')) {
|
|
139
|
+
console.log(JSON.stringify(out, null, 2));
|
|
140
|
+
}
|
|
@@ -33,6 +33,10 @@ Três checks novos no catálogo de `health.mjs` (`scope: repo`), sobre um scanne
|
|
|
33
33
|
instrução existe no registry. Comando fantasma faz o agente agir errado — trava.
|
|
34
34
|
- **`commands-documented`** (warn): todo comando do registry é mencionado em ao menos um `.md`.
|
|
35
35
|
- **`docs-links`** (warn): todo link markdown relativo entre arquivos versionados resolve.
|
|
36
|
+
- **`adr-refs`** (warn, adicionado depois): toda citação `ADR-NNNN` em doc/spec/ADR aponta para um
|
|
37
|
+
ADR que existe. Fecha o último invariante que vivia por disciplina ("toda decisão vira ADR") pelo
|
|
38
|
+
lado verificável: referência a decisão inexistente é trilha que apodrece. Pegou o `ADR-0026`
|
|
39
|
+
pendurado (citado pela SPEC-012, nunca escrito) na primeira execução.
|
|
36
40
|
|
|
37
41
|
Princípios:
|
|
38
42
|
|
|
@@ -0,0 +1,66 @@
|
|
|
1
|
+
# ADR-0026: Migração TypeScript com runtime duplo (fonte `.ts`, publicado `dist/`)
|
|
2
|
+
|
|
3
|
+
- **Status**: accepted
|
|
4
|
+
- **Data**: 2026-07-19
|
|
5
|
+
- **Autor(es)**: apk
|
|
6
|
+
- **Tags**: typescript, build, runtime, sdd
|
|
7
|
+
|
|
8
|
+
## Contexto
|
|
9
|
+
|
|
10
|
+
A SPEC-012 migrou o framework de `.mjs`/checkJs para TypeScript de verdade. Dois requisitos em
|
|
11
|
+
tensão organizaram todas as decisões:
|
|
12
|
+
|
|
13
|
+
- **NFR inegociável**: o dev roda `sem build`. `node bin/forja.ts <cmd>` tem que funcionar direto,
|
|
14
|
+
ou o loop de desenvolvimento morre.
|
|
15
|
+
- **`engines.node >= 20`**: o pacote publicado precisa rodar em Node 20/21, que **não** executam
|
|
16
|
+
`.ts` (strip-types nativo só existe a partir do Node 22.6).
|
|
17
|
+
|
|
18
|
+
Essas duas verdades não cabem no mesmo artefato: no instante em que a fonte vira `.ts`, um pacote
|
|
19
|
+
publicado sem compilar quebra para quem está em Node 20.
|
|
20
|
+
|
|
21
|
+
## Decisão
|
|
22
|
+
|
|
23
|
+
**Runtime duplo, resolvido por um único ponto.**
|
|
24
|
+
|
|
25
|
+
1. **D1 — Layout plano, `dist/` espelha a árvore.** `tsc rootDir=. outDir=dist` → `dist/bin`,
|
|
26
|
+
`dist/lib`, `dist/scripts`. Não movemos a fonte para `src/`: trocaria todo import, path de
|
|
27
|
+
registry e hook — blast radius enorme, contra o "verde contínuo".
|
|
28
|
+
2. **D2 — Registry + `resolveScript` (o coração).** O registry nomeia os scripts; o `resolveScript`
|
|
29
|
+
tenta as extensões na ordem `['.ts', '.js', '.mjs']`, fazendo strip da extensão declarada. Em dev
|
|
30
|
+
acha o `.ts`; no publicado acha o `dist/*.js`. Um resolver, dois mundos — sem dois registries
|
|
31
|
+
(a divergência que a SPEC-009 matou).
|
|
32
|
+
3. **D3 — Dual runtime.** Dev roda `.ts` nativo (Node ≥22.6, exigência de contribuir); o publicado
|
|
33
|
+
embarca `dist/*.js` (Node ≥20). O acoplamento de Node-floor vive só na fronteira do publicado.
|
|
34
|
+
4. **D4 (revisado) — o gate constrói o `dist/`.** O `release:check` roda `npm run build` **antes de
|
|
35
|
+
empacotar** (quando `files[]` inclui `dist/`). Como `npm publish` empacota o disco e o gate
|
|
36
|
+
empacota o mesmo disco recém-buildado, o tarball provado é o publicado — sem `dist/` no git, sem
|
|
37
|
+
step de build no `ci.yml`, sem janela de staleness. O gate é self-contained.
|
|
38
|
+
5. **D9 — publicar `dist/` desde sempre desacopla o risco.** Enquanto a fonte ainda era `.mjs`, o
|
|
39
|
+
build era uma cópia; quando virou `.ts`, virou compilação. Em ambos os casos o publicado é JS
|
|
40
|
+
runnable, então o `.ts`-não-roda-em-Node-20 nunca morde o usuário final.
|
|
41
|
+
|
|
42
|
+
## Alternativas consideradas
|
|
43
|
+
|
|
44
|
+
- **Guardar `.js` compilado no git e exigir build em dev** — rejeitada: mata o NFR "roda sem build".
|
|
45
|
+
- **Publicar a fonte `.ts` crua** — rejeitada: quebra em Node 20/21; o `release:check` reprovaria.
|
|
46
|
+
- **Dois registries (dev/publicado)** — rejeitada: duas verdades que divergem (defeito da SPEC-009).
|
|
47
|
+
- **Mover a fonte para `src/`** — rejeitada: blast radius desproporcional para ganho estético.
|
|
48
|
+
|
|
49
|
+
## Consequências
|
|
50
|
+
|
|
51
|
+
**Positivas**:
|
|
52
|
+
- Dev roda `.ts` nativo, zero build; usuário final roda `dist/*.js`, Node ≥20. Cada um paga só o seu.
|
|
53
|
+
- Uma máquina (`resolveScript`) resolve os dois mundos; o gate prova o tarball real.
|
|
54
|
+
- `noImplicitAny` ligado ao fim: o ratchet força todo código futuro a ser tipado.
|
|
55
|
+
|
|
56
|
+
**Negativas / Trade-offs**:
|
|
57
|
+
- Contribuir passa a exigir Node ≥22.6; o job `test` do CI cai fora do Node 20 (o suporte a 20 do
|
|
58
|
+
publicado é provado pelo `release-gate`, que instala o tarball `.js`).
|
|
59
|
+
- O `resolveScript` carrega três extensões por dívida histórica (`.mjs` legado) — barato, mas é
|
|
60
|
+
estado que um dia se limpa.
|
|
61
|
+
|
|
62
|
+
## Rastreamento
|
|
63
|
+
- Spec: `specs/ts-migration/` (SPEC-012)
|
|
64
|
+
- Implementação: `lib/core/registry.ts` (resolveScript), `lib/core/release.ts` (gate builda),
|
|
65
|
+
`tsconfig.json` / `tsconfig.build.json`, `.github/workflows/ci.yml`
|
|
66
|
+
- ADRs relacionadas: ADR-0021 (NFR "roda sem build"; classe "dist mente"), ADR-0024 (gate do tarball)
|
|
@@ -62,9 +62,40 @@ rica com lógica pobre, não arquitetura com arquitetura.
|
|
|
62
62
|
|
|
63
63
|
**Conclusão honesta**: o ganho é **navegacional** (não recarregar código não-relacionado + o mapa),
|
|
64
64
|
não de tamanho de arquivo. A medida crua feita aqui é um proxy fraco e **não prova** a economia. A
|
|
65
|
-
prova rigorosa precisa do
|
|
66
|
-
|
|
67
|
-
|
|
65
|
+
prova rigorosa precisa do benchmark sobre uma **mesma tarefa**, com a mesma feature nas duas
|
|
66
|
+
arquiteturas — o boilerplate flat não tinha um equivalente rico ao Order, então ficou como follow-up.
|
|
67
|
+
|
|
68
|
+
### Follow-up resolvido — o benchmark same-feature (`forja token:economy`)
|
|
69
|
+
|
|
70
|
+
A dívida acima foi fechada: existe um `benchmarks/clean-vs-flat/orders-flat/` (a MESMA feature —
|
|
71
|
+
place + ship + "não envia sem pagamento" — no estilo flat) e o comando `token:economy` mede **dois
|
|
72
|
+
eixos**, porque a economia de token do Forja tem dois eixos e eles são diferentes:
|
|
73
|
+
|
|
74
|
+
**Eixo 1 — arquitetura (clean vs flat).** Desmente a versão ingênua da claim:
|
|
75
|
+
|
|
76
|
+
| Cenário | Clean | Flat | Clean vs flat |
|
|
77
|
+
|---|---|---|---|
|
|
78
|
+
| Entender a feature inteira | ~3684 tok (12 arq.) | ~1298 tok (3 arq.) | **+184%** |
|
|
79
|
+
| Mudar a regra de envio (contexto mínimo) | ~1419 tok (3 arq.) | ~910 tok (1 arq.) | **+56%** |
|
|
80
|
+
|
|
81
|
+
Para uma feature pequena, **o clean-arch custa MAIS tokens** — inclusive na mudança localizada. A
|
|
82
|
+
camada cobra adiantado e, com dois casos de uso, não se paga. **A justificativa de `orders` em
|
|
83
|
+
camadas passa a ser isolamento e testabilidade, não token.**
|
|
84
|
+
|
|
85
|
+
**Eixo 2 — memória (frio vs quente).** É aqui que a economia real do framework mora (ADR-0009):
|
|
86
|
+
|
|
87
|
+
| Cenário | Quente (com `context.md`) | Frio (sem mapa) | Economia |
|
|
88
|
+
|---|---|---|---|
|
|
89
|
+
| Localizar e mexer numa regra da fatia | ~1419 tok (3 arq.) | ~3684 tok (12 arq.) | **−61%** |
|
|
90
|
+
|
|
91
|
+
O `context.md` é o mapa: com ele, o agente vai direto ao agregado + à máquina de estados; sem ele,
|
|
92
|
+
varre a fatia inteira para descobrir onde a regra vive. **E essa economia COMPÕE**: gerar do zero é
|
|
93
|
+
custo único (o scaffold), mas o mapa poupa a cada tarefa futura, pela vida do projeto. O
|
|
94
|
+
`token:economy` não mede o custo de gerar — mede o regime permanente, depois do projeto levantado.
|
|
95
|
+
|
|
96
|
+
Conclusão corrigida: a economia de token do Forja **não é das camadas — é da memória persistente**,
|
|
97
|
+
amortizada no tempo. As camadas se pagam só a partir de certa escala (tamanho da feature × nº de
|
|
98
|
+
casos de uso); a memória se paga desde a segunda tarefa. Tudo reproduzível: `forja token:economy`.
|
|
68
99
|
|
|
69
100
|
## Alternativas consideradas
|
|
70
101
|
|