forjajs 1.6.1 → 1.6.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CHANGELOG.md CHANGED
@@ -4,6 +4,24 @@ Histórico consolidado das mudanças estruturais do framework. Para decisões ar
4
4
 
5
5
  ---
6
6
 
7
+ ## [1.6.2] — 2026-07-21 — Correção: `spec:new` em projetos consumidores
8
+
9
+ ### Corrigido
10
+ - **`forja spec:new` num projeto consumidor escrevia a spec DENTRO de `node_modules/forjajs/dist`**
11
+ e falhava com "template ausente". Duas causas: o dispatcher spawnava os filhos com `cwd` = raiz do
12
+ pacote (agora usa o cwd de quem invocou — uma CLI opera onde é chamada), e o `spec-cli` resolvia
13
+ templates e destino por uma raiz só (agora separa `pkgRoot`, de onde vêm os templates, de
14
+ `targetRoot`, onde as specs nascem). Framework inalterado.
15
+ - Sem `.gitignore` ou sem bloco de allowlist: silêncio em vez de aviso — num consumidor esse é o
16
+ estado saudável (specs versionadas normalmente).
17
+
18
+ ### Adicionado
19
+ - **Gate `consumer-spec-new`** no `release:check`: roda `spec:new` na instalação limpa e reprova se a
20
+ spec não nascer no projeto do consumidor ou vazar para dentro do pacote. O smoke pegava "não
21
+ carrega"; este pega "opera no mundo errado".
22
+
23
+ ---
24
+
7
25
  ## [1.6.1] — 2026-07-20 — Correção: `project:upgrade` no pacote publicado
8
26
 
9
27
  ### Corrigido
package/dist/bin/forja.js CHANGED
@@ -108,16 +108,21 @@ if (gateErrors.length) {
108
108
  }
109
109
  const started = Date.now();
110
110
  let result;
111
+ // Os filhos rodam ONDE O USUÁRIO INVOCOU, não na raiz do pacote. `cwd: root` funcionava por
112
+ // coincidência no repo do framework (invoca-se da raiz), mas no pacote instalado `root` é
113
+ // `node_modules/forjajs/dist` — e comandos que operam no projeto do usuário (spec:new) escreviam
114
+ // DENTRO do pacote (bug da v1.6.1). Scripts do framework não dependem de cwd: resolvem seus paths
115
+ // por __dirname (repo) ou pelo workspace (absoluto).
111
116
  if (cmd.node) {
112
117
  const script = resolveScript(root, cmd.node);
113
118
  result = spawnSync('node', [script, ...(cmd.args || []), ...rest], {
114
- cwd: root,
119
+ cwd: process.cwd(),
115
120
  stdio: 'inherit',
116
121
  });
117
122
  }
118
123
  else {
119
124
  result = spawnSync(cmd.bin, [...(cmd.args || []), ...rest], {
120
- cwd: root,
125
+ cwd: process.cwd(),
121
126
  stdio: 'inherit',
122
127
  });
123
128
  if (result.error && result.error.code === 'ENOENT') {
@@ -394,12 +394,52 @@ const smokeCommands = {
394
394
  };
395
395
  },
396
396
  };
397
+ /**
398
+ * O bug da v1.6.1, generalizado: um comando pode CARREGAR limpo (o smoke passa) e ainda assim operar
399
+ * no mundo errado — `spec:new` escrevia dentro de `node_modules/forjajs/dist` e não achava os
400
+ * templates, porque resolvia tudo por `__dirname` e o dispatcher impunha `cwd` = raiz do pacote.
401
+ * Nenhuma assinatura de loader denuncia isso; só EXECUTAR o comando no mundo do consumidor e conferir
402
+ * ONDE o efeito aconteceu. É o smoke, um degrau acima: de "carrega" para "opera no lugar certo".
403
+ * O efeito colateral fica contido no installDir temporário, que é limpo sempre.
404
+ */
405
+ const consumerSpecNew = {
406
+ id: 'consumer-spec-new',
407
+ title: 'spec:new opera no projeto do consumidor, não dentro do pacote',
408
+ severity: 'critical',
409
+ dependsOn: 'install',
410
+ probe(env) {
411
+ const pkg = JSON.parse(env.fs.readFileSync(path.join(env.pkgDir, 'package.json'), 'utf8'));
412
+ const binRel = typeof pkg.bin === 'string' ? pkg.bin : pkg.bin?.forja;
413
+ const bin = path.join(env.pkgDir, binRel);
414
+ const res = env.spawn(process.execPath, [bin, 'spec:new', 'smoke-consumer-spec'], { cwd: env.installDir });
415
+ const noProjeto = env.fs.existsSync(path.join(env.installDir, 'specs', 'smoke-consumer-spec', 'spec.md'));
416
+ const dentroDoPacote = env.fs.existsSync(path.join(env.pkgDir, 'specs', 'smoke-consumer-spec'))
417
+ || env.fs.existsSync(path.join(env.pkgDir, 'dist', 'specs', 'smoke-consumer-spec'));
418
+ if (dentroDoPacote) {
419
+ return {
420
+ status: 'fail',
421
+ detail: 'spec:new escreveu DENTRO de node_modules/forjajs — o comando opera no mundo errado',
422
+ fix: 'o dispatcher deve spawnar com o cwd do usuário e o spec-cli separar pkgRoot de targetRoot',
423
+ };
424
+ }
425
+ if (!noProjeto) {
426
+ const saida = `${res.stdout || ''}${res.stderr || ''}`.trim().split('\n')[0] || 'sem saída';
427
+ return {
428
+ status: 'fail',
429
+ detail: `spec:new não criou a spec no projeto do consumidor: ${saida}`,
430
+ fix: 'confira a resolução dos templates (pkgRoot) e do destino (cwd) no spec-cli',
431
+ };
432
+ }
433
+ return { status: 'ok', detail: 'spec criada no projeto do consumidor; templates do pacote resolvem', fix: null };
434
+ },
435
+ };
397
436
  /** @type {import('./checks.ts').Check[]} */
398
437
  export const RELEASE_CHECKS = [
399
438
  treeClean,
400
439
  install,
401
440
  registryScripts,
402
441
  smokeCommands,
442
+ consumerSpecNew,
403
443
  importsResolve,
404
444
  depsDeclared,
405
445
  depsUnused,
@@ -12,6 +12,18 @@
12
12
  * - feature-slug em kebab-case
13
13
  * - status na frontmatter-like "- **Status**: ..." linha 3
14
14
  */
15
+ import fs from 'node:fs';
16
+ /**
17
+ * Duas raízes, de propósito (bug da v1.6.1: eram uma só, e no pacote instalado tudo apontava para
18
+ * `node_modules/forjajs/dist` — spec:new escrevia DENTRO do pacote e não achava os templates):
19
+ *
20
+ * - `pkgRoot` → de onde vêm os TEMPLATES. No dev é a raiz do repo (`scripts/..`); no publicado os
21
+ * templates viajam na raiz do pacote, um nível acima do `dist/` (`dist/scripts/../..`). O probe
22
+ * acha qual das duas tem `specs/_templates` de verdade.
23
+ * - `targetRoot` → onde as SPECS nascem: o projeto de quem invocou (`process.cwd()`, propagado pelo
24
+ * dispatcher). No repo do framework, cwd é a raiz do repo — comportamento inalterado.
25
+ */
26
+ export declare function resolvePkgRoot(scriptDir: string, fsImpl?: typeof fs): string;
15
27
  /**
16
28
  * `.gitignore` ignora `/specs/*` e libera as specs do framework por allow-list. Uma spec nova
17
29
  * nascia invisível ao git: criada, aprovada pelo check, e descartada em silêncio. A regra existia
@@ -18,9 +18,27 @@ import process from 'node:process';
18
18
  import { fileURLToPath } from 'node:url';
19
19
  const __filename = fileURLToPath(import.meta.url);
20
20
  const __dirname = path.dirname(__filename);
21
- const repoRoot = path.resolve(__dirname, '..');
22
- const specsDir = path.join(repoRoot, 'specs');
23
- const templatesDir = path.join(specsDir, '_templates');
21
+ /**
22
+ * Duas raízes, de propósito (bug da v1.6.1: eram uma só, e no pacote instalado tudo apontava para
23
+ * `node_modules/forjajs/dist` — spec:new escrevia DENTRO do pacote e não achava os templates):
24
+ *
25
+ * - `pkgRoot` → de onde vêm os TEMPLATES. No dev é a raiz do repo (`scripts/..`); no publicado os
26
+ * templates viajam na raiz do pacote, um nível acima do `dist/` (`dist/scripts/../..`). O probe
27
+ * acha qual das duas tem `specs/_templates` de verdade.
28
+ * - `targetRoot` → onde as SPECS nascem: o projeto de quem invocou (`process.cwd()`, propagado pelo
29
+ * dispatcher). No repo do framework, cwd é a raiz do repo — comportamento inalterado.
30
+ */
31
+ export function resolvePkgRoot(scriptDir, fsImpl = fs) {
32
+ for (const cand of [path.resolve(scriptDir, '..'), path.resolve(scriptDir, '..', '..')]) {
33
+ if (fsImpl.existsSync(path.join(cand, 'specs', '_templates')))
34
+ return cand;
35
+ }
36
+ return path.resolve(scriptDir, '..');
37
+ }
38
+ const pkgRoot = resolvePkgRoot(__dirname);
39
+ const targetRoot = process.cwd();
40
+ const specsDir = path.join(targetRoot, 'specs');
41
+ const templatesDir = path.join(pkgRoot, 'specs', '_templates');
24
42
  const STAGES = ['spec', 'plan', 'tasks'];
25
43
  const STATUS_RE = /-\s*\*\*Status\*\*:\s*([a-z]+)[^\n]*/i;
26
44
  const VALID_STATUSES = ['draft', 'review', 'approved', 'implementing', 'done', 'abandoned'];
@@ -98,9 +116,14 @@ export function addSpecToAllowlist(content, slug) {
98
116
  return { changed: true, content: lines.join('\n'), reason: 'added' };
99
117
  }
100
118
  function gitignorePath() {
101
- return process.env.FORJA_GITIGNORE || path.join(repoRoot, '.gitignore');
119
+ return process.env.FORJA_GITIGNORE || path.join(targetRoot, '.gitignore');
102
120
  }
103
- /** Efeito colateral de `spec:new`. Nunca derruba a criação da spec — criar a spec é o trabalho. */
121
+ /**
122
+ * Efeito colateral de `spec:new`. Nunca derruba a criação da spec — criar a spec é o trabalho.
123
+ * A allowlist `!/specs/<slug>` só existe no repo do FRAMEWORK (que ignora `/specs/*` por padrão).
124
+ * Num projeto consumidor não há bloco — e isso é o estado saudável: specs são versionadas
125
+ * normalmente. Por isso "sem .gitignore" e "sem bloco" são silêncio, não aviso.
126
+ */
104
127
  function ensureSpecVersioned(slug) {
105
128
  const file = gitignorePath();
106
129
  let raw;
@@ -108,13 +131,11 @@ function ensureSpecVersioned(slug) {
108
131
  raw = fs.readFileSync(file, 'utf8');
109
132
  }
110
133
  catch {
111
- out(' ⚠ .gitignore não encontrado — confira se a spec será versionada.');
112
- return;
134
+ return; // sem .gitignore — nada a ajustar
113
135
  }
114
136
  const result = addSpecToAllowlist(raw, slug);
115
137
  if (result.reason === 'no-block') {
116
- out(' ⚠ bloco allow-list de specs ausente no .gitignore — versione a spec manualmente.');
117
- return;
138
+ return; // sem bloco de allowlist — specs não são ignoradas; nada a fazer
118
139
  }
119
140
  if (!result.changed)
120
141
  return;
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "forjajs",
3
- "version": "1.6.1",
3
+ "version": "1.6.2",
4
4
  "description": "Forja — framework CLI-first de orquestração multiagente, memória hierárquica e geração de projetos com IA",
5
5
  "type": "module",
6
6
  "main": "index.js",