@fontdata/ai-harness 4.5.0 → 4.5.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/.claude-plugin/plugin.json +2 -2
- package/README.md +40 -13
- package/dist/config/config.js +29 -3
- package/dist/delphi/catalogo.js +94 -52
- package/dist/delphi/classificar.js +10 -6
- package/dist/delphi/command.js +32 -6
- package/dist/delphi/uses.js +90 -0
- package/dist/doctor/checks.js +37 -6
- package/dist/install/perfis.js +6 -2
- package/package.json +1 -1
- package/templates/catalog.json +1 -1
|
@@ -1,8 +1,8 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "fontdata",
|
|
3
|
-
"version": "4.5.
|
|
3
|
+
"version": "4.5.2",
|
|
4
4
|
"mcpServers": {
|
|
5
|
-
"banco_dados": { "command": "npx", "args": ["-y", "@fontdata/ai-harness@4.5.
|
|
5
|
+
"banco_dados": { "command": "npx", "args": ["-y", "@fontdata/ai-harness@4.5.2", "banco-dados-mcp"] }
|
|
6
6
|
},
|
|
7
7
|
"description": "Harness de engenharia com IA da Fontdata para Claude Code",
|
|
8
8
|
"author": { "name": "Fontdata" },
|
package/README.md
CHANGED
|
@@ -144,9 +144,19 @@ rules do projeto que repetem uma rule do perfil: tirar a duplicata fica com voc
|
|
|
144
144
|
|
|
145
145
|
### Perfil `delphi-fiscal`
|
|
146
146
|
|
|
147
|
-
Quando o projeto recebe o perfil Delphi e usa ACBr
|
|
148
|
-
`
|
|
149
|
-
|
|
147
|
+
Quando o projeto recebe o perfil Delphi e usa ACBr, o `init` e o `update` instalam também o perfil `delphi-fiscal`,
|
|
148
|
+
como o item `perfil:delphi-fiscal` no lock. Como o perfil Delphi, ele fica fora do plugin. O ACBr é detectado assim:
|
|
149
|
+
|
|
150
|
+
- algum `.dproj` (pelo mesmo critério de detecção do Delphi) ou o `boss.json` da raiz cita `ACBr`, sem diferenciar
|
|
151
|
+
maiúsculas;
|
|
152
|
+
- senão, alguma `.pas` ou `.dpr` tem uma unit `ACBr...` (como `ACBrNFe`) na cláusula `uses`, fora de comentário e de
|
|
153
|
+
string. Isso pega o projeto que usa ACBr por DCU pré-compilada, sem pacote no `.dproj` nem `boss.json`. Num
|
|
154
|
+
repositório git, só contam os arquivos versionados (`git ls-files`); fora dele, os encontrados até 4 níveis de
|
|
155
|
+
pasta. Nos dois casos, o que casa com `delphi.ignorar` fica de fora.
|
|
156
|
+
|
|
157
|
+
Se a detecção não pegar o seu caso, grave `"perfis": { "delphi-fiscal": true }` no `.ai-harness/config.json` e rode
|
|
158
|
+
`npx @fontdata/ai-harness update --yes`: o `true` gravado no arquivo liga o perfil mesmo sem ACBr detectado. Sem a
|
|
159
|
+
chave, a detecção decide.
|
|
150
160
|
|
|
151
161
|
| O que instala | Onde |
|
|
152
162
|
|---|---|
|
|
@@ -155,8 +165,8 @@ Quando o projeto recebe o perfil Delphi e usa ACBr — algum `.dproj` (pelo mesm
|
|
|
155
165
|
|
|
156
166
|
Para recusar, grave `"perfis": { "delphi-fiscal": false }` no `.ai-harness/config.json` e rode
|
|
157
167
|
`npx @fontdata/ai-harness update --yes`: o `update` tira o item do lock e **mantém** os arquivos. A recusa do perfil
|
|
158
|
-
Delphi (`perfis.delphi: false`) recusa também o fiscal e tira os dois itens do lock
|
|
159
|
-
recusa ou porque o projeto não é Delphi, o fiscal não é instalado.
|
|
168
|
+
Delphi (`perfis.delphi: false`) recusa também o fiscal e tira os dois itens do lock, mesmo com o `true` do fiscal
|
|
169
|
+
gravado. Sem o perfil Delphi, por recusa ou porque o projeto não é Delphi, o fiscal não é instalado.
|
|
160
170
|
|
|
161
171
|
### Hook `delphi-encoding`
|
|
162
172
|
|
|
@@ -225,14 +235,31 @@ helper. Por unit `Fontdata.*.pas`, ele traz os tipos públicos da `interface` e,
|
|
|
225
235
|
propriedades `public` e `published`, com a assinatura; os class helpers trazem também o tipo que estendem. A lista de
|
|
226
236
|
fontes guarda o nome de cada unit e o `sha256` do conteúdo, sem caminho, então o catálogo pode ser versionado.
|
|
227
237
|
|
|
228
|
-
- Sem `--pasta`, as units são procuradas nas pastas do `DCC_UnitSearchPath` de todos os `.dproj` do projeto
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
238
|
+
- Sem `--pasta`, as units são procuradas nas pastas do `DCC_UnitSearchPath` de todos os `.dproj` do projeto. A
|
|
239
|
+
entrada relativa é resolvida a partir da pasta de cada `.dproj`, e a relativa com `$(...)` é ignorada.
|
|
240
|
+
- Um caminho absoluto do Windows ou UNC (`D:\DESEN\Delphi\Bibliotecas\Utils`, `\\servidor\share\Fontdata`) é usado
|
|
241
|
+
como está quando existe nesta máquina, o que é o caso no Windows. Se ele não existir, como no macOS ou no Linux, é
|
|
242
|
+
reancorado pelo sufixo: o trecho depois da raiz (`D:\`, `\\servidor\share`) é procurado sob cada pasta ancestral do
|
|
243
|
+
`.dproj`, do sufixo mais longo ao mais curto, com pelo menos 2 segmentos. Por exemplo, `D:\DESEN\Delphi\Bibliotecas\Utils`
|
|
244
|
+
casa com `~/Documents/DESEN/Delphi/Bibliotecas/Utils` quando o `.dproj` fica dentro de `~/Documents/DESEN`. O
|
|
245
|
+
caminho que não casa com nada fica sem resolver, e o absoluto com `$(...)` nunca é resolvido.
|
|
246
|
+
- `--pasta <dir>`, que pode se repetir, troca o search path pelas pastas informadas. Ao gerar o catálogo, as pastas
|
|
247
|
+
ficam guardadas em `delphi.catalogo.pastas` no `.ai-harness/config.json`, relativas à raiz do projeto e com `/`
|
|
248
|
+
(`../../Bibliotecas/Utils`), ou absolutas quando não há relativo possível, como numa outra unidade do Windows.
|
|
249
|
+
Depois disso, o comando sem `--pasta`, o `--check` e o `doctor` usam as pastas guardadas no lugar do search path.
|
|
250
|
+
Para voltar ao search path, apague a chave; para trocar as pastas, rode `--pasta` de novo.
|
|
251
|
+
- `--check` não grava nada e sai com código 1 quando o catálogo falta ou diverge das units atuais. Se alguma pasta
|
|
252
|
+
guardada não existe nesta máquina, ele não compara nada e sai com código 1, citando as pastas que faltam.
|
|
253
|
+
|
|
254
|
+
Nenhuma unit encontrada é erro: o comando lista os caminhos absolutos do Windows que não foram encontrados nesta
|
|
255
|
+
máquina e pede `--pasta` com o caminho das Bibliotecas Fontdata. Num projeto com o perfil Delphi e units `Fontdata.*`
|
|
256
|
+
no search path, o `doctor` avisa `catalogo-fontdata-ausente` quando o catálogo não existe e
|
|
257
|
+
`catalogo-fontdata-desatualizado` quando ele não bate com as units. Quando nenhuma unit é achada, há caminho absoluto
|
|
258
|
+
sem resolver e alguma `.pas` ou `.dpr` usa uma unit `Fontdata.*` na cláusula `uses` (pelos mesmos arquivos e o mesmo
|
|
259
|
+
`delphi.ignorar` da detecção do ACBr), o `doctor` avisa `catalogo-fontdata-caminho-nao-resolvido`, lista os caminhos
|
|
260
|
+
e sugere `delphi catalogo --pasta <dir>`; esse aviso só vale sem pastas guardadas. Com uma pasta de
|
|
261
|
+
`delphi.catalogo.pastas` ausente nesta máquina, o `doctor` não confere o catálogo e avisa
|
|
262
|
+
`catalogo-fontdata-pastas-ausentes`, com as pastas que faltam. Fora desses casos, não há aviso de catálogo.
|
|
236
263
|
|
|
237
264
|
## Conexões de banco de dados
|
|
238
265
|
|
package/dist/config/config.js
CHANGED
|
@@ -77,7 +77,8 @@ export function defaultConfig() {
|
|
|
77
77
|
},
|
|
78
78
|
comentarios: { instalar: true },
|
|
79
79
|
perfis: { delphi: true, 'delphi-fiscal': true },
|
|
80
|
-
|
|
80
|
+
perfisExplicitos: {},
|
|
81
|
+
delphi: { ignorar: [...DELPHI_IGNORAR_PADRAO], catalogo: {} },
|
|
81
82
|
};
|
|
82
83
|
}
|
|
83
84
|
function inteiroEntre(value, min, max) {
|
|
@@ -248,8 +249,10 @@ export function readConfig(root) {
|
|
|
248
249
|
if (!isObject(raw.perfis) || !(perfil in raw.perfis))
|
|
249
250
|
continue;
|
|
250
251
|
const valor = raw.perfis[perfil];
|
|
251
|
-
if (typeof valor === 'boolean')
|
|
252
|
+
if (typeof valor === 'boolean') {
|
|
252
253
|
config.perfis[perfil] = valor;
|
|
254
|
+
config.perfisExplicitos[perfil] = valor;
|
|
255
|
+
}
|
|
253
256
|
else
|
|
254
257
|
problems.push(`perfis.${perfil} deve ser true ou false em ${CONFIG_PATH}.`);
|
|
255
258
|
}
|
|
@@ -260,6 +263,14 @@ export function readConfig(root) {
|
|
|
260
263
|
else
|
|
261
264
|
problems.push(`delphi.ignorar deve ser uma lista de globs (texto) em ${CONFIG_PATH}; valem os padrões.`);
|
|
262
265
|
}
|
|
266
|
+
if (isObject(raw.delphi) && 'catalogo' in raw.delphi) {
|
|
267
|
+
const catalogo = raw.delphi.catalogo;
|
|
268
|
+
const pastas = isObject(catalogo) ? catalogo.pastas : null;
|
|
269
|
+
if (Array.isArray(pastas) && pastas.every((pasta) => typeof pasta === 'string' && pasta !== ''))
|
|
270
|
+
config.delphi.catalogo.pastas = pastas;
|
|
271
|
+
else if (pastas !== undefined)
|
|
272
|
+
problems.push(`delphi.catalogo.pastas deve ser uma lista de pastas (texto) em ${CONFIG_PATH}; vale o search path dos .dproj.`);
|
|
273
|
+
}
|
|
263
274
|
const secao = soSecaoLegada(raw) ? raw[BANCO_CHAVE_LEGADA] : raw[BANCO_CHAVE];
|
|
264
275
|
if (isObject(secao))
|
|
265
276
|
lerBanco(secao, config.banco_dados, problems);
|
|
@@ -273,7 +284,7 @@ export function readConfig(root) {
|
|
|
273
284
|
}
|
|
274
285
|
/** Os padrões que vão para o arquivo: sem as seções banco_dados, comentarios, perfis e delphi, que só entram quando mudam. */
|
|
275
286
|
function configGravada() {
|
|
276
|
-
const { banco_dados: _banco, comentarios: _comentarios, perfis: _perfis, delphi: _delphi, ...gravada } = defaultConfig();
|
|
287
|
+
const { banco_dados: _banco, comentarios: _comentarios, perfis: _perfis, perfisExplicitos: _perfisExplicitos, delphi: _delphi, ...gravada } = defaultConfig();
|
|
277
288
|
return gravada;
|
|
278
289
|
}
|
|
279
290
|
/** Cria a config com os padrões, sem as seções que só entram quando mudam; retorna false se já existia (nunca sobrescreve). */
|
|
@@ -415,6 +426,21 @@ export function gravarPerfil(root, perfil, valor) {
|
|
|
415
426
|
export function gravarPerfilDelphi(root, valor) {
|
|
416
427
|
gravarPerfil(root, 'delphi', valor);
|
|
417
428
|
}
|
|
429
|
+
/**
|
|
430
|
+
* Grava `delphi.catalogo.pastas`, preservando o resto do JSON; sem config, cria uma com os padrões e essa chave.
|
|
431
|
+
* Não escreve se a lista já é a mesma. JSON inválido é recusado sem tocar no arquivo.
|
|
432
|
+
*/
|
|
433
|
+
export function gravarPastasCatalogo(root, pastas) {
|
|
434
|
+
const file = join(root, CONFIG_PATH);
|
|
435
|
+
const raw = existsSync(file) ? lerJsonParaEscrita(file, 'delphi.catalogo.pastas') : configGravada();
|
|
436
|
+
const delphi = isObject(raw.delphi) ? raw.delphi : {};
|
|
437
|
+
const catalogo = isObject(delphi.catalogo) ? delphi.catalogo : {};
|
|
438
|
+
if (JSON.stringify(catalogo.pastas) === JSON.stringify(pastas))
|
|
439
|
+
return;
|
|
440
|
+
const proxima = { ...raw, delphi: { ...delphi, catalogo: { ...catalogo, pastas } } };
|
|
441
|
+
mkdirSync(dirname(file), { recursive: true });
|
|
442
|
+
writeFileSync(file, `${JSON.stringify(proxima, null, 2)}\n`);
|
|
443
|
+
}
|
|
418
444
|
const BLOCK_START = '# ai-harness (gerenciado pelo harness; não edite entre estas linhas)';
|
|
419
445
|
const BLOCK_END = '# /ai-harness';
|
|
420
446
|
/**
|
package/dist/delphi/catalogo.js
CHANGED
|
@@ -1,8 +1,9 @@
|
|
|
1
|
-
import { existsSync, readdirSync, readFileSync } from 'node:fs';
|
|
2
|
-
import {
|
|
1
|
+
import { existsSync, readdirSync, readFileSync, realpathSync } from 'node:fs';
|
|
2
|
+
import path, { join } from 'node:path';
|
|
3
3
|
import { hashContent } from '../install/lock.js';
|
|
4
4
|
import { semComentariosPascal } from '../mapa/extratores/pascal.js';
|
|
5
5
|
import { arquivosDproj } from './classificar.js';
|
|
6
|
+
import { mascararStrings } from './uses.js';
|
|
6
7
|
export const CAMINHO_CATALOGO = '.claude/skills/conhecimento-delphi/references/bibliotecas-fontdata.md';
|
|
7
8
|
const VISIBILIDADE = /^(strict\s+private|strict\s+protected|private|protected|public|published|automated)\b\s*/i;
|
|
8
9
|
const SECAO_DO_TIPO = /^(class\s+var|type|const|var|threadvar|resourcestring)\b\s*/i;
|
|
@@ -15,8 +16,49 @@ const CABECALHO = /^([A-Za-z_]\w*(?:\s*<[^>]*>)?)\s*=\s*(.*)$/;
|
|
|
15
16
|
const HELPER = /^((?:class|record)\s+helper\s*(?:\([^)]*\))?\s+for\s+[\w.]+(?:\s*<[^>]*>)?)\s*(.*)$/i;
|
|
16
17
|
const ESTRUTURA = /^((?:packed\s+)?(class|record|object|interface|dispinterface)\b(?:\s+(?:sealed|abstract))?\s*(?:\([^)]*\))?\s*(?:\[[^\]]*\])?)\s*(.*)$/i;
|
|
17
18
|
const RECORD_ANONIMO = /^[\w\s,]+:\s*(packed\s+)?record\b\s*(.*)$/i;
|
|
18
|
-
|
|
19
|
-
|
|
19
|
+
const RAIZ_WINDOWS = /^(?:[A-Za-z]:[\\/]|[\\/]{2}[^\\/]+[\\/][^\\/]+)/;
|
|
20
|
+
function* ancestrais(pasta, caminho) {
|
|
21
|
+
for (let atual = pasta;;) {
|
|
22
|
+
yield atual;
|
|
23
|
+
const pai = caminho.dirname(atual);
|
|
24
|
+
if (pai === atual)
|
|
25
|
+
return;
|
|
26
|
+
atual = pai;
|
|
27
|
+
}
|
|
28
|
+
}
|
|
29
|
+
/**
|
|
30
|
+
* Pasta de uma entrada do search path, ou `null` para a entrada absoluta do Windows ou UNC sem correspondente:
|
|
31
|
+
* o literal vale quando o `caminho` a considera absoluta e ela existe; senão, o sufixo de pelo menos 2 segmentos,
|
|
32
|
+
* do mais longo ao mais curto, é procurado sob cada ancestral de `pastaDoDproj`.
|
|
33
|
+
*/
|
|
34
|
+
export function resolverEntrada(entrada, pastaDoDproj, opcoes = {}) {
|
|
35
|
+
const { caminho = path, existe = existsSync } = opcoes;
|
|
36
|
+
const raizWindows = RAIZ_WINDOWS.exec(entrada);
|
|
37
|
+
if (!raizWindows)
|
|
38
|
+
return caminho.resolve(pastaDoDproj, entrada.replace(/\\/g, '/'));
|
|
39
|
+
if (caminho.isAbsolute(entrada)) {
|
|
40
|
+
const literal = caminho.normalize(entrada);
|
|
41
|
+
if (existe(literal))
|
|
42
|
+
return literal;
|
|
43
|
+
}
|
|
44
|
+
const segmentos = entrada
|
|
45
|
+
.slice(raizWindows[0].length)
|
|
46
|
+
.split(/[\\/]+/)
|
|
47
|
+
.filter((segmento) => segmento && segmento !== '.');
|
|
48
|
+
for (let tamanho = segmentos.length; tamanho >= 2; tamanho--) {
|
|
49
|
+
const sufixo = segmentos.slice(segmentos.length - tamanho);
|
|
50
|
+
for (const ancestral of ancestrais(pastaDoDproj, caminho)) {
|
|
51
|
+
const candidato = caminho.join(ancestral, ...sufixo);
|
|
52
|
+
if (existe(candidato))
|
|
53
|
+
return candidato;
|
|
54
|
+
}
|
|
55
|
+
}
|
|
56
|
+
return null;
|
|
57
|
+
}
|
|
58
|
+
/** Pastas do `DCC_UnitSearchPath` de todos os `.dproj`; a entrada relativa com `$(...)` é ignorada. */
|
|
59
|
+
export function resolverSearchPath(raiz, opcoes = {}) {
|
|
60
|
+
const caminho = opcoes.caminho ?? path;
|
|
61
|
+
const resultado = { pastas: [], naoResolvidas: [] };
|
|
20
62
|
for (const rel of arquivosDproj(raiz)) {
|
|
21
63
|
const dproj = join(raiz, rel);
|
|
22
64
|
let xml;
|
|
@@ -27,17 +69,58 @@ export function pastasDoSearchPath(raiz) {
|
|
|
27
69
|
continue;
|
|
28
70
|
}
|
|
29
71
|
for (const grupo of xml.matchAll(/<DCC_UnitSearchPath>([\s\S]*?)<\/DCC_UnitSearchPath>/gi)) {
|
|
30
|
-
for (const
|
|
31
|
-
const
|
|
32
|
-
if (!
|
|
72
|
+
for (const bruta of (grupo[1] ?? '').split(';')) {
|
|
73
|
+
const entrada = bruta.trim();
|
|
74
|
+
if (!entrada)
|
|
75
|
+
continue;
|
|
76
|
+
const comMacro = entrada.includes('$(');
|
|
77
|
+
if (comMacro && !RAIZ_WINDOWS.test(entrada))
|
|
33
78
|
continue;
|
|
34
|
-
const pasta =
|
|
35
|
-
|
|
36
|
-
|
|
79
|
+
const pasta = comMacro ? null : resolverEntrada(entrada, caminho.dirname(dproj), opcoes);
|
|
80
|
+
const lista = pasta === null ? resultado.naoResolvidas : resultado.pastas;
|
|
81
|
+
const valor = pasta ?? entrada;
|
|
82
|
+
if (!lista.includes(valor))
|
|
83
|
+
lista.push(valor);
|
|
37
84
|
}
|
|
38
85
|
}
|
|
39
86
|
}
|
|
40
|
-
return
|
|
87
|
+
return resultado;
|
|
88
|
+
}
|
|
89
|
+
export function pastasDoSearchPath(raiz) {
|
|
90
|
+
return resolverSearchPath(raiz).pastas;
|
|
91
|
+
}
|
|
92
|
+
/** A pasta como vai para `delphi.catalogo.pastas`: relativa à raiz com `/`, ou absoluta quando não há relativo (outra unidade). */
|
|
93
|
+
export function pastaParaGuardar(raiz, pastaAbs, opcoes = {}) {
|
|
94
|
+
const { caminho = path } = opcoes;
|
|
95
|
+
const relativa = caminho.relative(raiz, pastaAbs);
|
|
96
|
+
if (caminho.isAbsolute(relativa))
|
|
97
|
+
return caminho.normalize(pastaAbs);
|
|
98
|
+
return relativa === '' ? '.' : relativa.split(caminho.sep).join('/');
|
|
99
|
+
}
|
|
100
|
+
function caminhoReal(pasta) {
|
|
101
|
+
try {
|
|
102
|
+
return realpathSync(pasta);
|
|
103
|
+
}
|
|
104
|
+
catch {
|
|
105
|
+
return pasta;
|
|
106
|
+
}
|
|
107
|
+
}
|
|
108
|
+
/**
|
|
109
|
+
* Resolve `delphi.catalogo.pastas` sobre o caminho real da raiz, o mesmo de onde a gravação calcula o relativo;
|
|
110
|
+
* sem pastas guardadas, as duas listas vêm vazias.
|
|
111
|
+
*/
|
|
112
|
+
export function pastasGuardadas(raiz, config, opcoes = {}) {
|
|
113
|
+
const { caminho = path, existe = existsSync } = opcoes;
|
|
114
|
+
const base = caminhoReal(raiz);
|
|
115
|
+
const resultado = { pastas: [], ausentes: [] };
|
|
116
|
+
for (const guardada of config.delphi.catalogo.pastas ?? []) {
|
|
117
|
+
const pasta = caminho.isAbsolute(guardada) ? caminho.normalize(guardada) : caminho.resolve(base, guardada);
|
|
118
|
+
if (existe(pasta))
|
|
119
|
+
resultado.pastas.push(pasta);
|
|
120
|
+
else
|
|
121
|
+
resultado.ausentes.push(guardada);
|
|
122
|
+
}
|
|
123
|
+
return resultado;
|
|
41
124
|
}
|
|
42
125
|
export function acharUnitsFontdata(pastas) {
|
|
43
126
|
const units = new Map();
|
|
@@ -66,47 +149,6 @@ export function acharUnitsFontdata(pastas) {
|
|
|
66
149
|
function semStrings(texto) {
|
|
67
150
|
return texto.replace(/'[^'\n]*'/g, (m) => m.replace(/[^\n]/g, ' '));
|
|
68
151
|
}
|
|
69
|
-
function mascararStrings(fonte) {
|
|
70
|
-
let saida = '';
|
|
71
|
-
let fimDoComentario = null;
|
|
72
|
-
let emString = false;
|
|
73
|
-
for (let i = 0; i < fonte.length; i++) {
|
|
74
|
-
const c = fonte[i];
|
|
75
|
-
if (fimDoComentario) {
|
|
76
|
-
if (fonte.startsWith(fimDoComentario, i) && fimDoComentario.length > 1) {
|
|
77
|
-
saida += fimDoComentario;
|
|
78
|
-
i += fimDoComentario.length - 1;
|
|
79
|
-
fimDoComentario = null;
|
|
80
|
-
continue;
|
|
81
|
-
}
|
|
82
|
-
if (c === fimDoComentario)
|
|
83
|
-
fimDoComentario = null;
|
|
84
|
-
saida += c;
|
|
85
|
-
}
|
|
86
|
-
else if (emString) {
|
|
87
|
-
if (c === "'" && fonte[i + 1] === "'") {
|
|
88
|
-
saida += '__';
|
|
89
|
-
i++;
|
|
90
|
-
continue;
|
|
91
|
-
}
|
|
92
|
-
if (c === "'" || c === '\n')
|
|
93
|
-
emString = false;
|
|
94
|
-
saida += c === "'" || c === '\n' ? c : '_';
|
|
95
|
-
}
|
|
96
|
-
else {
|
|
97
|
-
if (c === "'")
|
|
98
|
-
emString = true;
|
|
99
|
-
else if (c === '{')
|
|
100
|
-
fimDoComentario = '}';
|
|
101
|
-
else if (c === '/' && fonte[i + 1] === '/')
|
|
102
|
-
fimDoComentario = '\n';
|
|
103
|
-
else if (c === '(' && fonte[i + 1] === '*')
|
|
104
|
-
fimDoComentario = '*)';
|
|
105
|
-
saida += c;
|
|
106
|
-
}
|
|
107
|
-
}
|
|
108
|
-
return saida;
|
|
109
|
-
}
|
|
110
152
|
function semComentariosPreservandoStrings(fonte) {
|
|
111
153
|
const mascarado = mascararStrings(fonte);
|
|
112
154
|
const limpo = semComentariosPascal(mascarado);
|
|
@@ -3,6 +3,8 @@ import { dirname, join, relative, sep } from 'node:path';
|
|
|
3
3
|
import { git, isVersioned } from '../trabalhos/arquivar.js';
|
|
4
4
|
import { varrerArquivos } from '../versao/detectar.js';
|
|
5
5
|
import { lerRes } from './res.js';
|
|
6
|
+
import { algumUsesCasa, emRepositorioGit } from './uses.js';
|
|
7
|
+
export { emRepositorioGit };
|
|
6
8
|
const RT_ICON = 3;
|
|
7
9
|
const RT_RCDATA = 10;
|
|
8
10
|
const RT_GROUP_ICON = 14;
|
|
@@ -30,12 +32,14 @@ function citaAcbr(arquivo) {
|
|
|
30
32
|
return false;
|
|
31
33
|
}
|
|
32
34
|
}
|
|
33
|
-
/**
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
export function
|
|
38
|
-
|
|
35
|
+
/**
|
|
36
|
+
* Algum `.dproj` ou o `boss.json` da raiz cita ACBr, sem diferenciar maiúsculas; sem achado, alguma `.pas`/`.dpr`
|
|
37
|
+
* fora de `ignorar` tem uma unit `ACBr[A-Z]...` na cláusula `uses`.
|
|
38
|
+
*/
|
|
39
|
+
export function detectarAcbr(raiz, ignorar) {
|
|
40
|
+
if (citaAcbr(join(raiz, 'boss.json')) || arquivosDproj(raiz).some((rel) => citaAcbr(join(raiz, rel))))
|
|
41
|
+
return true;
|
|
42
|
+
return algumUsesCasa(raiz, (unit) => /^ACBr[A-Z]/.test(unit), ignorar);
|
|
39
43
|
}
|
|
40
44
|
function mesmoNome(nome, esperado) {
|
|
41
45
|
return typeof nome === 'string' && nome.toUpperCase() === esperado;
|
package/dist/delphi/command.js
CHANGED
|
@@ -1,9 +1,9 @@
|
|
|
1
|
-
import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
|
|
1
|
+
import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
|
|
2
2
|
import { basename, dirname, extname, join, resolve } from 'node:path';
|
|
3
|
-
import { readConfig } from '../config/config.js';
|
|
3
|
+
import { CONFIG_PATH, gravarPastasCatalogo, readConfig } from '../config/config.js';
|
|
4
4
|
import { acharRaiz } from '../raiz.js';
|
|
5
5
|
import { git } from '../trabalhos/arquivar.js';
|
|
6
|
-
import { acharUnitsFontdata, CAMINHO_CATALOGO, estadoDoCatalogo, gerarCatalogo,
|
|
6
|
+
import { acharUnitsFontdata, CAMINHO_CATALOGO, estadoDoCatalogo, gerarCatalogo, pastaParaGuardar, pastasGuardadas, resolverSearchPath, } from './catalogo.js';
|
|
7
7
|
import { classificarRes, detectarDelphi, emRepositorioGit } from './classificar.js';
|
|
8
8
|
import { casaGlob, checarArquivo, converterParaUtf8Bom, detectarEncoding, detectarEol, EXTENSOES_CONVERTER, EXTENSOES_DELPHI, } from './encoding.js';
|
|
9
9
|
import { extrairIcone } from './icone.js';
|
|
@@ -181,10 +181,26 @@ function catalogo(args) {
|
|
|
181
181
|
}
|
|
182
182
|
}
|
|
183
183
|
const raiz = acharRaiz();
|
|
184
|
-
const
|
|
184
|
+
const { config } = readConfig(raiz);
|
|
185
|
+
const guardadas = pastasGuardadas(raiz, config);
|
|
186
|
+
if (pastas.length === 0 && guardadas.ausentes.length > 0) {
|
|
187
|
+
console.error(`Estas pastas de delphi.catalogo.pastas em ${CONFIG_PATH} não existem nesta máquina:`);
|
|
188
|
+
for (const ausente of guardadas.ausentes)
|
|
189
|
+
console.error(` ${ausente}`);
|
|
190
|
+
console.error('Nada foi comparado. Crie as pastas, rode delphi catalogo --pasta <dir> para trocar as pastas guardadas, ou apague delphi.catalogo.pastas para voltar ao search path.');
|
|
191
|
+
return 1;
|
|
192
|
+
}
|
|
193
|
+
const searchPath = pastas.length > 0 ? { pastas, naoResolvidas: [] } : guardadas.pastas.length > 0 ? { pastas: guardadas.pastas, naoResolvidas: [] } : resolverSearchPath(raiz);
|
|
194
|
+
const units = acharUnitsFontdata(searchPath.pastas);
|
|
185
195
|
if (units.length === 0) {
|
|
186
|
-
const onde = pastas.length > 0 ? 'nas pastas informadas' : 'no DCC_UnitSearchPath dos .dproj do projeto';
|
|
187
|
-
console.error(`Nenhuma unit Fontdata.*.pas encontrada ${onde}
|
|
196
|
+
const onde = pastas.length > 0 ? 'nas pastas informadas' : guardadas.pastas.length > 0 ? 'nas pastas de delphi.catalogo.pastas' : 'no DCC_UnitSearchPath dos .dproj do projeto';
|
|
197
|
+
console.error(`Nenhuma unit Fontdata.*.pas encontrada ${onde}.`);
|
|
198
|
+
if (searchPath.naoResolvidas.length > 0) {
|
|
199
|
+
console.error('Estes caminhos absolutos do Windows não foram encontrados nesta máquina:');
|
|
200
|
+
for (const entrada of searchPath.naoResolvidas)
|
|
201
|
+
console.error(` ${entrada}`);
|
|
202
|
+
}
|
|
203
|
+
console.error('Passe --pasta <dir> com a pasta das units.');
|
|
188
204
|
return 1;
|
|
189
205
|
}
|
|
190
206
|
const destino = join(raiz, CAMINHO_CATALOGO);
|
|
@@ -198,6 +214,16 @@ function catalogo(args) {
|
|
|
198
214
|
console.error(`O catálogo ${CAMINHO_CATALOGO} ${motivo}: rode npx @fontdata/ai-harness delphi catalogo.`);
|
|
199
215
|
return 1;
|
|
200
216
|
}
|
|
217
|
+
if (pastas.length > 0) {
|
|
218
|
+
const raizReal = realpathSync(raiz);
|
|
219
|
+
try {
|
|
220
|
+
gravarPastasCatalogo(raiz, pastas.map((pasta) => pastaParaGuardar(raizReal, existsSync(pasta) ? realpathSync(pasta) : pasta)));
|
|
221
|
+
}
|
|
222
|
+
catch (erro) {
|
|
223
|
+
console.error(erro instanceof Error ? erro.message : String(erro));
|
|
224
|
+
return 1;
|
|
225
|
+
}
|
|
226
|
+
}
|
|
201
227
|
mkdirSync(dirname(destino), { recursive: true });
|
|
202
228
|
writeFileSync(destino, gerarCatalogo(units));
|
|
203
229
|
console.log(`Catálogo de ${units.length} unit(s) Fontdata gravado em ${CAMINHO_CATALOGO}.`);
|
|
@@ -0,0 +1,90 @@
|
|
|
1
|
+
import { readFileSync } from 'node:fs';
|
|
2
|
+
import { join } from 'node:path';
|
|
3
|
+
import { semComentariosPascal } from '../mapa/extratores/pascal.js';
|
|
4
|
+
import { git } from '../trabalhos/arquivar.js';
|
|
5
|
+
import { varrerArquivos } from '../versao/detectar.js';
|
|
6
|
+
import { casaGlob } from './encoding.js';
|
|
7
|
+
/** Troca o conteúdo das strings Pascal por `_`, mantendo aspas, comentários e posições. */
|
|
8
|
+
export function mascararStrings(fonte) {
|
|
9
|
+
let saida = '';
|
|
10
|
+
let fimDoComentario = null;
|
|
11
|
+
let emString = false;
|
|
12
|
+
for (let i = 0; i < fonte.length; i++) {
|
|
13
|
+
const c = fonte[i];
|
|
14
|
+
if (fimDoComentario) {
|
|
15
|
+
if (fonte.startsWith(fimDoComentario, i) && fimDoComentario.length > 1) {
|
|
16
|
+
saida += fimDoComentario;
|
|
17
|
+
i += fimDoComentario.length - 1;
|
|
18
|
+
fimDoComentario = null;
|
|
19
|
+
continue;
|
|
20
|
+
}
|
|
21
|
+
if (c === fimDoComentario)
|
|
22
|
+
fimDoComentario = null;
|
|
23
|
+
saida += c;
|
|
24
|
+
}
|
|
25
|
+
else if (emString) {
|
|
26
|
+
if (c === "'" && fonte[i + 1] === "'") {
|
|
27
|
+
saida += '__';
|
|
28
|
+
i++;
|
|
29
|
+
continue;
|
|
30
|
+
}
|
|
31
|
+
if (c === "'" || c === '\n')
|
|
32
|
+
emString = false;
|
|
33
|
+
saida += c === "'" || c === '\n' ? c : '_';
|
|
34
|
+
}
|
|
35
|
+
else {
|
|
36
|
+
if (c === "'")
|
|
37
|
+
emString = true;
|
|
38
|
+
else if (c === '{')
|
|
39
|
+
fimDoComentario = '}';
|
|
40
|
+
else if (c === '/' && fonte[i + 1] === '/')
|
|
41
|
+
fimDoComentario = '\n';
|
|
42
|
+
else if (c === '(' && fonte[i + 1] === '*')
|
|
43
|
+
fimDoComentario = '*)';
|
|
44
|
+
saida += c;
|
|
45
|
+
}
|
|
46
|
+
}
|
|
47
|
+
return saida;
|
|
48
|
+
}
|
|
49
|
+
/** Nomes das units de todas as cláusulas `uses` do fonte, inclusive os com ponto, fora de comentário e string. */
|
|
50
|
+
export function unitsDoUses(fonte) {
|
|
51
|
+
const limpo = semComentariosPascal(mascararStrings(fonte.replace(/^/, '')));
|
|
52
|
+
const units = [];
|
|
53
|
+
for (const clausula of limpo.matchAll(/\buses\b([^;]*);/gi)) {
|
|
54
|
+
for (const item of (clausula[1] ?? '').split(',')) {
|
|
55
|
+
const nome = /^\s*([A-Za-z_][\w.]*)/.exec(item)?.[1];
|
|
56
|
+
if (nome)
|
|
57
|
+
units.push(nome);
|
|
58
|
+
}
|
|
59
|
+
}
|
|
60
|
+
return units;
|
|
61
|
+
}
|
|
62
|
+
export function emRepositorioGit(raiz) {
|
|
63
|
+
return git(raiz, ['rev-parse', '--is-inside-work-tree'])?.trim() === 'true';
|
|
64
|
+
}
|
|
65
|
+
function fontesDelphi(raiz) {
|
|
66
|
+
if (!emRepositorioGit(raiz))
|
|
67
|
+
return varrerArquivos(raiz, '', 4, /\.(pas|dpr)$/i);
|
|
68
|
+
const saida = git(raiz, ['ls-files', '-z', '--', ':(icase)*.pas', ':(icase)*.dpr']) ?? '';
|
|
69
|
+
return saida.split('\0').filter(Boolean);
|
|
70
|
+
}
|
|
71
|
+
/**
|
|
72
|
+
* Se alguma `.pas`/`.dpr` do projeto, fora de `ignorar`, tem na cláusula `uses` uma unit que passa no `teste`.
|
|
73
|
+
* Dentro de git só contam os arquivos do `git ls-files`; fora, os encontrados até 4 níveis de pasta.
|
|
74
|
+
*/
|
|
75
|
+
export function algumUsesCasa(raiz, teste, ignorar) {
|
|
76
|
+
for (const rel of fontesDelphi(raiz)) {
|
|
77
|
+
if (casaGlob(rel, ignorar))
|
|
78
|
+
continue;
|
|
79
|
+
let fonte;
|
|
80
|
+
try {
|
|
81
|
+
fonte = readFileSync(join(raiz, rel), 'utf8');
|
|
82
|
+
}
|
|
83
|
+
catch {
|
|
84
|
+
continue;
|
|
85
|
+
}
|
|
86
|
+
if (unitsDoUses(fonte).some(teste))
|
|
87
|
+
return true;
|
|
88
|
+
}
|
|
89
|
+
return false;
|
|
90
|
+
}
|
package/dist/doctor/checks.js
CHANGED
|
@@ -8,8 +8,9 @@ import { COMMENTS_HOOK_PATH, hookProprioRegistrado } from '../comentarios/instal
|
|
|
8
8
|
import { CONFIG_PATH, readConfig } from '../config/config.js';
|
|
9
9
|
import { ARCHIVE_DIR_NAME, ARTIFACT_TYPES, listWorkFiles, readArtifact, validateAllWorks, WORKS_DIR } from '../contratos/artefatos.js';
|
|
10
10
|
import { validateEventLog } from '../contratos/eventos.js';
|
|
11
|
-
import { CAMINHO_CATALOGO, checarCatalogo } from '../delphi/catalogo.js';
|
|
11
|
+
import { CAMINHO_CATALOGO, checarCatalogo, pastasGuardadas, resolverSearchPath } from '../delphi/catalogo.js';
|
|
12
12
|
import { classificarRes } from '../delphi/classificar.js';
|
|
13
|
+
import { algumUsesCasa } from '../delphi/uses.js';
|
|
13
14
|
import { hashContent, LOCK_PATH, LOCK_VERSION } from '../install/lock.js';
|
|
14
15
|
import { agentsForaDoLock, itemSources } from '../install/plan.js';
|
|
15
16
|
import { hookCommands, SETTINGS_PATH } from '../install/settings.js';
|
|
@@ -265,19 +266,49 @@ function checkDelphiRes(root) {
|
|
|
265
266
|
correcao: 'Rode a etapa `/harness ignores` para classificar, extrair o ícone se preciso e tirar o .res do versionamento com aprovação.',
|
|
266
267
|
}));
|
|
267
268
|
}
|
|
268
|
-
function
|
|
269
|
+
function checkCaminhoNaoResolvido(root, naoResolvidas, config) {
|
|
270
|
+
if (naoResolvidas.length === 0)
|
|
271
|
+
return [];
|
|
272
|
+
if (!algumUsesCasa(root, (unit) => unit.startsWith('Fontdata.'), config.delphi.ignorar))
|
|
273
|
+
return [];
|
|
274
|
+
return [
|
|
275
|
+
{
|
|
276
|
+
id: 'catalogo-fontdata-caminho-nao-resolvido',
|
|
277
|
+
severidade: 'aviso',
|
|
278
|
+
mensagem: `O código usa units Fontdata.*, mas estes caminhos absolutos do DCC_UnitSearchPath não existem nesta máquina: ${naoResolvidas.join(', ')}.`,
|
|
279
|
+
correcao: 'Rode `npx @fontdata/ai-harness delphi catalogo --pasta <dir>` com a pasta das units Fontdata.*.pas.',
|
|
280
|
+
},
|
|
281
|
+
];
|
|
282
|
+
}
|
|
283
|
+
function checkCatalogoFontdata(root, lock, config) {
|
|
269
284
|
if (!lock.itens.some((item) => item.tipo === 'perfil' && item.id === 'delphi'))
|
|
270
285
|
return [];
|
|
271
|
-
const
|
|
286
|
+
const guardadas = pastasGuardadas(root, config);
|
|
287
|
+
if (guardadas.ausentes.length > 0) {
|
|
288
|
+
return [
|
|
289
|
+
{
|
|
290
|
+
id: 'catalogo-fontdata-pastas-ausentes',
|
|
291
|
+
severidade: 'aviso',
|
|
292
|
+
mensagem: `Estas pastas de delphi.catalogo.pastas em ${CONFIG_PATH} não existem nesta máquina, e o catálogo não foi conferido: ${guardadas.ausentes.join(', ')}.`,
|
|
293
|
+
correcao: 'Crie as pastas, rode `npx @fontdata/ai-harness delphi catalogo --pasta <dir>` para trocar as pastas guardadas, ou apague delphi.catalogo.pastas para voltar ao search path.',
|
|
294
|
+
},
|
|
295
|
+
];
|
|
296
|
+
}
|
|
297
|
+
const comGuardadas = guardadas.pastas.length > 0;
|
|
298
|
+
const { pastas, naoResolvidas } = comGuardadas ? { pastas: guardadas.pastas, naoResolvidas: [] } : resolverSearchPath(root);
|
|
299
|
+
const estado = checarCatalogo(root, pastas);
|
|
300
|
+
if (estado === 'sem-units')
|
|
301
|
+
return checkCaminhoNaoResolvido(root, naoResolvidas, config);
|
|
272
302
|
if (estado !== 'ausente' && estado !== 'desatualizado')
|
|
273
303
|
return [];
|
|
304
|
+
const origem = comGuardadas ? 'das pastas de delphi.catalogo.pastas' : 'do search path';
|
|
274
305
|
return [
|
|
275
306
|
{
|
|
276
307
|
id: `catalogo-fontdata-${estado}`,
|
|
277
308
|
severidade: 'aviso',
|
|
278
309
|
mensagem: estado === 'ausente'
|
|
279
|
-
?
|
|
280
|
-
: `O catálogo ${CAMINHO_CATALOGO} não bate com as units Fontdata.*
|
|
310
|
+
? `${comGuardadas ? 'As pastas de delphi.catalogo.pastas têm' : 'O search path do projeto tem'} units Fontdata.*, mas o catálogo ${CAMINHO_CATALOGO} não existe.`
|
|
311
|
+
: `O catálogo ${CAMINHO_CATALOGO} não bate com as units Fontdata.* ${origem}.`,
|
|
281
312
|
correcao: 'Rode `npx @fontdata/ai-harness delphi catalogo` para gerar o catálogo de novo.',
|
|
282
313
|
},
|
|
283
314
|
];
|
|
@@ -673,7 +704,7 @@ export function runDoctor(root, options = {}) {
|
|
|
673
704
|
return [
|
|
674
705
|
...checkNode(options.nodeVersion ?? process.versions.node),
|
|
675
706
|
...lockFindings,
|
|
676
|
-
...(lock ? [...checkFiles(root, lock), ...checkRequiredSkills(root, lock), ...checkMissingHarnessAgents(root, lock), ...checkComments(root, lock, config), ...checkCatalogoFontdata(root, lock)] : []),
|
|
707
|
+
...(lock ? [...checkFiles(root, lock), ...checkRequiredSkills(root, lock), ...checkMissingHarnessAgents(root, lock), ...checkComments(root, lock, config), ...checkCatalogoFontdata(root, lock, config)] : []),
|
|
677
708
|
...checkShadowedCommands(root),
|
|
678
709
|
...checkOldCommentsBlock(root),
|
|
679
710
|
...checkAgents(root),
|
package/dist/install/perfis.js
CHANGED
|
@@ -2,11 +2,15 @@ import { PERFIS_DO_CONFIG } from '../config/config.js';
|
|
|
2
2
|
import { detectarAcbr, detectarDelphi } from '../delphi/classificar.js';
|
|
3
3
|
export const PERFIS = PERFIS_DO_CONFIG;
|
|
4
4
|
export const PERFIL_DELPHI_HOOK_COMMAND = 'node "${CLAUDE_PROJECT_DIR}/.claude/hooks/delphi/encoding.mjs"';
|
|
5
|
-
/**
|
|
5
|
+
/**
|
|
6
|
+
* Perfis que o projeto recebe: a stack foi detectada e o config não guarda a recusa. O fiscal depende do Delphi e
|
|
7
|
+
* entra também sem ACBr detectado quando o `true` está gravado no config.
|
|
8
|
+
*/
|
|
6
9
|
export function perfisDoProjeto(root, config) {
|
|
7
10
|
if (!config.perfis.delphi || !detectarDelphi(root))
|
|
8
11
|
return [];
|
|
9
|
-
|
|
12
|
+
const fiscal = config.perfisExplicitos['delphi-fiscal'] === true || (config.perfis['delphi-fiscal'] && detectarAcbr(root, config.delphi.ignorar));
|
|
13
|
+
return fiscal ? ['delphi', 'delphi-fiscal'] : ['delphi'];
|
|
10
14
|
}
|
|
11
15
|
/** A recusa do perfil no config; a do Delphi recusa também o fiscal. */
|
|
12
16
|
export function perfilRecusadoNoConfig(perfil, config) {
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@fontdata/ai-harness",
|
|
3
|
-
"version": "4.5.
|
|
3
|
+
"version": "4.5.2",
|
|
4
4
|
"description": "Harness de engenharia com IA da Fontdata para Claude Code: roda os slash commands direto na pasta do projeto via npx, sem instalar nada — ou instala-os em .claude/commands.",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"bin": {
|
package/templates/catalog.json
CHANGED
|
@@ -29,7 +29,7 @@
|
|
|
29
29
|
],
|
|
30
30
|
"perfis": [
|
|
31
31
|
{ "id": "delphi", "dir": "perfis/delphi", "title": "Perfil Delphi", "description": "Rules de Delphi, a skill conhecimento-delphi e o hook de encoding, instalados quando o projeto tem .dpr ou .dproj." },
|
|
32
|
-
{ "id": "delphi-fiscal", "dir": "perfis/delphi-fiscal", "title": "Perfil Delphi fiscal", "description": "Rules de documento fiscal com ACBr e as skills patch-acbr e diagnosticar-rejeicao-nfse, instalados com o perfil Delphi quando algum .dproj ou o boss.json cita ACBr." }
|
|
32
|
+
{ "id": "delphi-fiscal", "dir": "perfis/delphi-fiscal", "title": "Perfil Delphi fiscal", "description": "Rules de documento fiscal com ACBr e as skills patch-acbr e diagnosticar-rejeicao-nfse, instalados com o perfil Delphi quando algum .dproj ou o boss.json cita ACBr ou quando os uses de alguma unit .pas ou .dpr trazem uma unit ACBr." }
|
|
33
33
|
],
|
|
34
34
|
"groups": [
|
|
35
35
|
{
|