@fontdata/ai-harness 4.1.0 → 4.2.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.
@@ -1,8 +1,8 @@
1
1
  {
2
2
  "name": "fontdata",
3
- "version": "4.1.0",
3
+ "version": "4.2.0",
4
4
  "mcpServers": {
5
- "banco_dados": { "command": "npx", "args": ["-y", "@fontdata/ai-harness@4.1.0", "banco-dados-mcp"] }
5
+ "banco_dados": { "command": "npx", "args": ["-y", "@fontdata/ai-harness@4.2.0", "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
@@ -274,12 +274,18 @@ também acionado pelo modelo quando o pedido combina.
274
274
  - `/harness` **(skill)** — conduz o setup em etapas (ideia, contexto, ignores, plano do start, scaffold, peças do harness, auto-tag e execução); `/harness <etapa>` roda uma etapa isolada
275
275
 
276
276
  O padrão de comentários não é um comando: a rule, o hook e a catraca do legado vêm do `init` e do `update`. O
277
- `update` também o instala em projetos cujo lock é anterior a ele; um hook próprio que já existe, de versão antiga ou
278
- adaptado, é mantido e só entra no lock. Para recusar, use `--sem-comentarios` no `init` ou
279
- no `update`: a escolha fica em `comentarios.instalar: false` no `.ai-harness/config.json`, e o `update` a respeita.
277
+ `update` também o instala em projetos cujo lock é anterior a ele; um `check.mjs` próprio que já existe, de versão antiga
278
+ ou adaptado, é mantido e só entra no lock. Um hook registrado no `.claude/settings.json` com outro comando em
279
+ `.claude/hooks/comentarios/`, como um `check.js`, também é mantido e fica fora do lock: `init`, `update` e `comentarios`
280
+ não instalam nem registram o do pacote em paralelo. Para recusar, use `--sem-comentarios` no `init` ou
281
+ no `update`: a escolha fica em `comentarios.instalar: false` no `.ai-harness/config.json`, e os dois a respeitam.
280
282
  Para reativar, apague a chave e rode `update --yes` (ou `npx @fontdata/ai-harness comentarios --yes`). Sem o padrão
281
283
  e sem a recusa, o `doctor` avisa com `comentarios-ausente`.
282
284
 
285
+ Os agents novos do catálogo chegam pelo `update` a quem já tem agents do harness no lock; arquivo do projeto com o
286
+ mesmo nome é preservado, e lock sem nenhum agent (`--sem-agents`) continua sem eles. Enquanto um agent não chega, o
287
+ `doctor` avisa com `agent-harness-faltando`.
288
+
283
289
  A skill `lgpd-checker`, usada pela auditoria de segurança, é uma cópia vendorizada de
284
290
  [bittencourtthulio/lgpd-checker](https://github.com/bittencourtthulio/lgpd-checker); veja
285
291
  `templates/skills/lgpd-checker/ORIGEM.md`.
package/dist/cli.js CHANGED
@@ -21,6 +21,7 @@ const RESERVED = new Set([
21
21
  'banco-dados',
22
22
  'banco-dados-mcp',
23
23
  'versao',
24
+ 'delphi',
24
25
  'list',
25
26
  'run',
26
27
  'help',
@@ -68,6 +69,7 @@ Gerenciar:
68
69
  banco-dados <subcomando> Conexões de banco somente leitura: adicionar, listar, testar, usar, remover
69
70
  banco-dados-mcp Servidor MCP de leitura do banco, usado pelo Claude Code (stdio)
70
71
  versao detectar|calcular|aplicar Fontes de versão, próxima versão e gravação (--app, --json; aplicar --dry-run)
72
+ delphi classificar|extrair-icone .res de projetos Delphi: classificação e extração do ícone
71
73
  list Lista todos os comandos disponíveis no catálogo
72
74
 
73
75
  Init sem perguntas (CI):
@@ -183,6 +185,10 @@ async function main() {
183
185
  const { runVersaoCommand } = await import('./versao/command.js');
184
186
  process.exit(runVersaoCommand(argv.slice(1)));
185
187
  }
188
+ if (cmd === 'delphi') {
189
+ const { runDelphiCommand } = await import('./delphi/command.js');
190
+ process.exit(await runDelphiCommand(argv.slice(1)));
191
+ }
186
192
  if (cmd === 'run') {
187
193
  const id = argv[1];
188
194
  if (!id) {
@@ -8,7 +8,7 @@ import { hashContent } from '../install/lock.js';
8
8
  import { executePlan, packageInfo } from '../install/plan.js';
9
9
  import { mergeSettings } from '../install/settings.js';
10
10
  import { acharRaiz } from '../raiz.js';
11
- import { COMMENTS_BASELINE_PATH, COMMENTS_HOOK_PATH, COMMENTS_RULE_PATH, commentsHooksConfig, ensureCommentsBaseline } from './instalar.js';
11
+ import { COMMENTS_BASELINE_PATH, COMMENTS_HOOK_PATH, COMMENTS_RULE_PATH, commentsHooksConfig, ensureCommentsBaseline, hookProprioRegistrado } from './instalar.js';
12
12
  export { COMMENTS_HOOK_PATH } from './instalar.js';
13
13
  const FLAGS = ['--yes', '-y', '--sim'];
14
14
  /** `ai-harness comentarios [caminho] [--yes]`: instala a rule, o hook de comentários e a catraca do legado. */
@@ -32,6 +32,13 @@ export function runCommentsCommand(argv) {
32
32
  const root = path === undefined ? acharRaiz() : resolve(process.cwd(), path);
33
33
  if (!existsSync(root))
34
34
  throw new Error(`Pasta não encontrada: ${root}`);
35
+ if (hookProprioRegistrado(root)) {
36
+ console.log('O projeto já tem hook próprio de comentários registrado em .claude/settings.json: o do pacote não é instalado, para não rodarem em paralelo. ' +
37
+ 'Para usar o do pacote, remova esse registro e rode o comando de novo.');
38
+ if (yes)
39
+ gravarInstalarComentarios(root, true);
40
+ return 0;
41
+ }
35
42
  const rule = readFileSync(join(templatesDir, 'rules', 'comentarios.md'));
36
43
  const ruleTarget = join(root, COMMENTS_RULE_PATH);
37
44
  // Uma rule com outro conteúdo é do projeto: fica como está.
@@ -3,7 +3,9 @@ import { existsSync, readFileSync } from 'node:fs';
3
3
  import { join } from 'node:path';
4
4
  import { templatesDir } from '../catalog.js';
5
5
  import { hashContent } from '../install/lock.js';
6
+ import { hookCommands, normalizarComandoHook, SETTINGS_PATH } from '../install/settings.js';
6
7
  export const COMMENTS_HOOK_PATH = '.claude/hooks/comentarios/check.mjs';
8
+ export const COMMENTS_HOOK_TEMPLATE = join(templatesDir, 'hooks', 'comentarios', 'check.mjs');
7
9
  export const COMMENTS_BASELINE_PATH = '.claude/hooks/comentarios/baseline.json';
8
10
  export const COMMENTS_RULE_PATH = '.claude/rules/comentarios.md';
9
11
  /** Mesmo texto das instalações feitas pelas versões antigas do /configurar-comentarios, para o merge não duplicar. */
@@ -11,6 +13,22 @@ export const COMMENTS_HOOK_COMMAND = 'node "${CLAUDE_PROJECT_DIR}/.claude/hooks/
11
13
  export function commentsHooksConfig() {
12
14
  return { PostToolUse: [{ matcher: 'Write|Edit|MultiEdit', hooks: [{ type: 'command', command: COMMENTS_HOOK_COMMAND }] }] };
13
15
  }
16
+ /** O hook de comentários existe no projeto com conteúdo diferente do template do pacote. */
17
+ export function hookProprio(root) {
18
+ const local = join(root, COMMENTS_HOOK_PATH);
19
+ return existsSync(local) && hashContent(readFileSync(local)) !== hashContent(readFileSync(COMMENTS_HOOK_TEMPLATE));
20
+ }
21
+ /** O settings do projeto registra em `.claude/hooks/comentarios/` um comando que não é o do pacote, como um `check.js`. */
22
+ export function hookProprioRegistrado(root) {
23
+ let hooks;
24
+ try {
25
+ hooks = JSON.parse(readFileSync(join(root, SETTINGS_PATH), 'utf8')).hooks;
26
+ }
27
+ catch {
28
+ return false;
29
+ }
30
+ return hookCommands(hooks ?? {}).some((command) => command.includes('.claude/hooks/comentarios/') && normalizarComandoHook(command) !== COMMENTS_HOOK_COMMAND);
31
+ }
14
32
  /**
15
33
  * Gera a catraca do legado na primeira instalação e devolve quantos arquivos entraram nela. Devolve `null` quando
16
34
  * ela já existe (regerar reabriria tolerâncias que já desceram) ou quando o `check.mjs` do projeto não é o do
@@ -0,0 +1,126 @@
1
+ import { readdirSync, readFileSync } from 'node:fs';
2
+ import { dirname, join, relative, sep } from 'node:path';
3
+ import { git, isVersioned } from '../trabalhos/arquivar.js';
4
+ import { varrerArquivos } from '../versao/detectar.js';
5
+ import { lerRes } from './res.js';
6
+ const RT_ICON = 3;
7
+ const RT_RCDATA = 10;
8
+ const RT_GROUP_ICON = 14;
9
+ const RT_VERSION = 16;
10
+ const RT_MANIFEST = 24;
11
+ export function detectarDelphi(raiz) {
12
+ if (varrerArquivos(raiz, '', 3, /\.(dproj|dpr)$/i).length > 0)
13
+ return true;
14
+ return Boolean(git(raiz, ['ls-files', '--', ':(icase)*.dproj', ':(icase)*.dpr'])?.trim());
15
+ }
16
+ export function emRepositorioGit(raiz) {
17
+ return git(raiz, ['rev-parse', '--is-inside-work-tree'])?.trim() === 'true';
18
+ }
19
+ function mesmoNome(nome, esperado) {
20
+ return typeof nome === 'string' && nome.toUpperCase() === esperado;
21
+ }
22
+ function recursoRegeravel(r) {
23
+ if (r.tipo === RT_VERSION || r.tipo === RT_ICON || r.tipo === RT_MANIFEST)
24
+ return true;
25
+ if (r.tipo === RT_GROUP_ICON)
26
+ return mesmoNome(r.nome, 'MAINICON');
27
+ if (r.tipo === RT_RCDATA)
28
+ return mesmoNome(r.nome, 'PLATFORMTARGETS');
29
+ return false;
30
+ }
31
+ function descreverRecurso(r) {
32
+ return `tipo ${r.tipo}, nome ${r.nome}`;
33
+ }
34
+ function vendorizado(raiz, caminho) {
35
+ const saida = git(raiz, ['check-attr', '-z', 'linguist-vendored', '--', caminho]);
36
+ const valor = saida?.split('\0')[2];
37
+ return valor === 'set' || valor === 'true';
38
+ }
39
+ function acharNaPasta(pasta, nome) {
40
+ let entradas;
41
+ try {
42
+ entradas = readdirSync(pasta);
43
+ }
44
+ catch {
45
+ return null;
46
+ }
47
+ const alvo = nome.toLowerCase();
48
+ const achado = entradas.find((e) => e.toLowerCase() === alvo);
49
+ return achado === undefined ? null : join(pasta, achado);
50
+ }
51
+ function resolverSemCaixa(pasta, caminho) {
52
+ let atual = pasta;
53
+ for (const segmento of caminho.split(/[\\/]/)) {
54
+ if (atual === null)
55
+ return null;
56
+ if (segmento === '' || segmento === '.')
57
+ continue;
58
+ atual = segmento === '..' ? dirname(atual) : acharNaPasta(atual, segmento);
59
+ }
60
+ return atual;
61
+ }
62
+ function iconesProprios(dproj) {
63
+ const texto = readFileSync(dproj, 'utf8');
64
+ return [...texto.matchAll(/<Icon_MainIcon>([^<]*)<\/Icon_MainIcon>/gi)]
65
+ .map((m) => m[1].trim())
66
+ .filter((valor) => valor !== '' && !valor.toUpperCase().startsWith('$(BDS)'));
67
+ }
68
+ function paraPosix(caminho) {
69
+ return caminho.split(sep).join('/');
70
+ }
71
+ function classificar(raiz, caminho) {
72
+ if (vendorizado(raiz, caminho)) {
73
+ return { classe: 'manter', motivo: 'Pasta marcada como linguist-vendored no .gitattributes (biblioteca de terceiros).' };
74
+ }
75
+ const absoluto = join(raiz, caminho);
76
+ const pasta = dirname(absoluto);
77
+ const projeto = absoluto.slice(pasta.length + 1).replace(/\.res$/i, '');
78
+ const dpr = acharNaPasta(pasta, `${projeto}.dpr`);
79
+ const dproj = acharNaPasta(pasta, `${projeto}.dproj`);
80
+ if (dpr === null || dproj === null) {
81
+ const falta = [dpr === null ? `${projeto}.dpr` : null, dproj === null ? `${projeto}.dproj` : null].filter(Boolean);
82
+ return { classe: 'manter', motivo: `Falta ${falta.join(' e ')} na mesma pasta: a IDE não regera este .res.` };
83
+ }
84
+ let recursos;
85
+ try {
86
+ recursos = lerRes(readFileSync(absoluto));
87
+ }
88
+ catch (erro) {
89
+ return { classe: 'manter', motivo: `O .res não pôde ser lido: ${erro.message}` };
90
+ }
91
+ const proprios = recursos.filter((r) => !recursoRegeravel(r));
92
+ if (proprios.length > 0) {
93
+ return {
94
+ classe: 'manter',
95
+ motivo: `O .res tem recurso que a IDE não regera (${proprios.map(descreverRecurso).join('; ')}).`,
96
+ };
97
+ }
98
+ const temMainIcon = recursos.some((r) => r.tipo === RT_GROUP_ICON && mesmoNome(r.nome, 'MAINICON'));
99
+ const icones = iconesProprios(dproj);
100
+ if (temMainIcon && icones.length === 0) {
101
+ return {
102
+ classe: 'icone-so-no-res',
103
+ motivo: 'O .dproj não tem Icon_MainIcon próprio (só $(BDS)): o MAINICON existe só dentro do .res.',
104
+ };
105
+ }
106
+ for (const icone of icones) {
107
+ const ico = resolverSemCaixa(pasta, icone);
108
+ if (ico === null) {
109
+ return { classe: 'icone-so-no-res', motivo: `O Icon_MainIcon ${icone} não existe no disco: o ícone existe só dentro do .res.` };
110
+ }
111
+ if (!isVersioned(raiz, paraPosix(relative(raiz, ico)))) {
112
+ return { classe: 'icone-so-no-res', motivo: `O Icon_MainIcon ${icone} não está versionado: o ícone existe só dentro do .res.` };
113
+ }
114
+ }
115
+ return { classe: 'regeravel', motivo: 'Só tem os recursos que a IDE regera a partir do .dproj.' };
116
+ }
117
+ /** Classifica cada `.res` rastreado pelo git, com caminho relativo à raiz e `/`; fora de um repositório, `[]`. */
118
+ export function classificarRes(raiz) {
119
+ if (!emRepositorioGit(raiz))
120
+ return [];
121
+ const saida = git(raiz, ['ls-files', '-z', '--', ':(icase)*.res']) ?? '';
122
+ return saida
123
+ .split('\0')
124
+ .filter((caminho) => caminho !== '')
125
+ .map((caminho) => ({ caminho, ...classificar(raiz, caminho) }));
126
+ }
@@ -0,0 +1,76 @@
1
+ import { existsSync, readFileSync, writeFileSync } from 'node:fs';
2
+ import { basename, dirname, extname, join, resolve } from 'node:path';
3
+ import { acharRaiz } from '../raiz.js';
4
+ import { classificarRes, detectarDelphi, emRepositorioGit } from './classificar.js';
5
+ import { extrairIcone } from './icone.js';
6
+ import { lerRes } from './res.js';
7
+ const USO = `Uso:
8
+ npx @fontdata/ai-harness delphi classificar [raiz] [--json]
9
+ npx @fontdata/ai-harness delphi extrair-icone <arquivo.res> [--saida <arquivo.ico>]`;
10
+ function classificar(args) {
11
+ const json = args.includes('--json');
12
+ const posicionais = args.filter((arg) => arg !== '--json');
13
+ const raiz = posicionais[0] === undefined ? acharRaiz() : resolve(process.cwd(), posicionais[0]);
14
+ if (!emRepositorioGit(raiz)) {
15
+ console.error('Não é um repositório git: a classificação precisa do git ls-files.');
16
+ return 1;
17
+ }
18
+ const delphi = detectarDelphi(raiz);
19
+ const res = classificarRes(raiz);
20
+ if (json) {
21
+ console.log(JSON.stringify({ delphi, res }, null, 2));
22
+ return 0;
23
+ }
24
+ console.log(delphi ? 'Stack Delphi detectada.' : 'Stack Delphi não detectada.');
25
+ if (res.length === 0) {
26
+ console.log('Nenhum .res rastreado pelo git.');
27
+ return 0;
28
+ }
29
+ for (const item of res)
30
+ console.log(` ${item.caminho} ${item.classe} ${item.motivo}`);
31
+ return 0;
32
+ }
33
+ function extrairIconeDoRes(args) {
34
+ const posicionais = [];
35
+ let saida;
36
+ for (let i = 0; i < args.length; i++) {
37
+ if (args[i] === '--saida')
38
+ saida = args[++i];
39
+ else
40
+ posicionais.push(args[i]);
41
+ }
42
+ const arquivo = posicionais[0];
43
+ if (!arquivo || (args.includes('--saida') && !saida)) {
44
+ console.error(USO);
45
+ return 1;
46
+ }
47
+ const origem = resolve(process.cwd(), arquivo);
48
+ const destino = saida
49
+ ? resolve(process.cwd(), saida)
50
+ : join(dirname(origem), `${basename(origem, extname(origem))}_Icon.ico`);
51
+ if (existsSync(destino)) {
52
+ console.error(`O arquivo ${destino} já existe; não foi sobrescrito.`);
53
+ return 1;
54
+ }
55
+ let icone;
56
+ try {
57
+ icone = extrairIcone(lerRes(readFileSync(origem)));
58
+ }
59
+ catch (erro) {
60
+ const mensagem = erro instanceof Error ? erro.message : String(erro);
61
+ console.error(`Não foi possível extrair o ícone de ${origem}: ${mensagem}`);
62
+ return 1;
63
+ }
64
+ writeFileSync(destino, icone, { flag: 'wx' });
65
+ console.log(`Ícone MAINICON gravado em ${destino}.`);
66
+ return 0;
67
+ }
68
+ export async function runDelphiCommand(args) {
69
+ const [sub, ...resto] = args;
70
+ if (sub === 'classificar')
71
+ return classificar(resto);
72
+ if (sub === 'extrair-icone')
73
+ return extrairIconeDoRes(resto);
74
+ console.error(USO);
75
+ return 1;
76
+ }
@@ -0,0 +1,37 @@
1
+ const RT_ICON = 3;
2
+ const RT_GROUP_ICON = 14;
3
+ /**
4
+ * Monta o .ico a partir do RT_GROUP_ICON MAINICON e dos RT_ICON que ele referencia.
5
+ * Com dois RT_ICON de mesmo id, vale o primeiro.
6
+ */
7
+ export function extrairIcone(recursos) {
8
+ const grupo = recursos.find((r) => r.tipo === RT_GROUP_ICON && typeof r.nome === 'string' && r.nome.toUpperCase() === 'MAINICON');
9
+ if (!grupo)
10
+ throw new Error('O .res não tem o grupo de ícones MAINICON.');
11
+ const dados = grupo.dados;
12
+ if (dados.length < 6)
13
+ throw new Error('Grupo de ícones MAINICON truncado.');
14
+ const count = dados.readUInt16LE(4);
15
+ if (dados.length < 6 + 14 * count)
16
+ throw new Error('Grupo de ícones MAINICON truncado.');
17
+ const blobs = [];
18
+ for (let i = 0; i < count; i++) {
19
+ const id = dados.readUInt16LE(6 + 14 * i + 12);
20
+ const icone = recursos.find((r) => r.tipo === RT_ICON && r.nome === id);
21
+ if (!icone)
22
+ throw new Error(`O grupo MAINICON referencia o RT_ICON ${id}, que não existe no .res.`);
23
+ blobs.push(icone.dados);
24
+ }
25
+ const cabecalho = Buffer.alloc(6 + 16 * count);
26
+ cabecalho.writeUInt16LE(0, 0);
27
+ cabecalho.writeUInt16LE(1, 2);
28
+ cabecalho.writeUInt16LE(count, 4);
29
+ let offsetBlob = cabecalho.length;
30
+ blobs.forEach((blob, i) => {
31
+ const entrada = 6 + 16 * i;
32
+ dados.copy(cabecalho, entrada, 6 + 14 * i, 6 + 14 * i + 12);
33
+ cabecalho.writeUInt32LE(offsetBlob, entrada + 12);
34
+ offsetBlob += blob.length;
35
+ });
36
+ return Buffer.concat([cabecalho, ...blobs]);
37
+ }
@@ -0,0 +1,47 @@
1
+ function alinhar4(valor) {
2
+ return (valor + 3) & ~3;
3
+ }
4
+ function lerIdentificador(buffer, inicio, fim) {
5
+ if (inicio + 2 > fim)
6
+ throw new Error(`Cabeçalho de recurso inválido no offset ${inicio} do .res.`);
7
+ if (buffer.readUInt16LE(inicio) === 0xffff) {
8
+ if (inicio + 4 > fim)
9
+ throw new Error(`Cabeçalho de recurso inválido no offset ${inicio} do .res.`);
10
+ return { valor: buffer.readUInt16LE(inicio + 2), proximo: inicio + 4 };
11
+ }
12
+ for (let i = inicio; i + 2 <= fim; i += 2) {
13
+ if (buffer.readUInt16LE(i) === 0) {
14
+ return { valor: buffer.toString('utf16le', inicio, i), proximo: i + 2 };
15
+ }
16
+ }
17
+ throw new Error(`Cabeçalho de recurso inválido no offset ${inicio} do .res: nome sem terminador.`);
18
+ }
19
+ /**
20
+ * Lê um arquivo de recursos Win32 de 32 bits, ignorando a entrada vazia do início.
21
+ * Lança Error em pt-BR quando o arquivo está truncado ou tem cabeçalho inválido.
22
+ */
23
+ export function lerRes(buffer) {
24
+ const recursos = [];
25
+ let offset = 0;
26
+ while (offset < buffer.length) {
27
+ if (offset + 8 > buffer.length)
28
+ throw new Error(`Arquivo .res truncado no offset ${offset}.`);
29
+ const dataSize = buffer.readUInt32LE(offset);
30
+ const headerSize = buffer.readUInt32LE(offset + 4);
31
+ if (headerSize < 16) {
32
+ throw new Error(`Cabeçalho de recurso inválido no offset ${offset} do .res: HeaderSize ${headerSize}.`);
33
+ }
34
+ const fimCabecalho = offset + headerSize;
35
+ const fimDados = fimCabecalho + dataSize;
36
+ if (fimDados > buffer.length)
37
+ throw new Error(`Arquivo .res truncado no recurso do offset ${offset}.`);
38
+ const tipo = lerIdentificador(buffer, offset + 8, fimCabecalho);
39
+ const nome = lerIdentificador(buffer, tipo.proximo, fimCabecalho);
40
+ const vazia = offset === 0 && dataSize === 0 && tipo.valor === 0;
41
+ if (!vazia) {
42
+ recursos.push({ tipo: tipo.valor, nome: nome.valor, dados: Buffer.from(buffer.subarray(fimCabecalho, fimDados)) });
43
+ }
44
+ offset = alinhar4(fimDados);
45
+ }
46
+ return recursos;
47
+ }
@@ -4,13 +4,14 @@ import { join } from 'node:path';
4
4
  import { lerEnvSettingsLocal, lerVariavel, SETTINGS_LOCAL_PATH } from '../banco-dados/ambiente.js';
5
5
  import { caminhoCadastro, lerCadastro } from '../banco-dados/cadastro.js';
6
6
  import { allCommands, loadCatalog } from '../catalog.js';
7
- import { COMMENTS_HOOK_PATH } from '../comentarios/instalar.js';
7
+ import { COMMENTS_HOOK_PATH, hookProprioRegistrado } from '../comentarios/instalar.js';
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 { classificarRes } from '../delphi/classificar.js';
11
12
  import { hashContent, LOCK_PATH, LOCK_VERSION } from '../install/lock.js';
12
- import { itemSources } from '../install/plan.js';
13
- import { SETTINGS_PATH } from '../install/settings.js';
13
+ import { agentsForaDoLock, itemSources } from '../install/plan.js';
14
+ import { hookCommands, SETTINGS_PATH } from '../install/settings.js';
14
15
  import { planArchive } from '../trabalhos/arquivar.js';
15
16
  import { ARCHIVE_DEFAULT_DAYS } from '../trabalhos/command.js';
16
17
  import { ARCHIVE_INDEX, readArchiveIndex } from '../trabalhos/indice-arquivo.js';
@@ -172,8 +173,20 @@ function checkAgents(root) {
172
173
  correcao: 'Declare `tools:` só com as ferramentas de que ele precisa (ex.: `tools: Read, Grep, Glob`).',
173
174
  }));
174
175
  }
175
- function hookCommands(hooks) {
176
- return Object.values(hooks).flatMap((groups) => (Array.isArray(groups) ? groups : []).flatMap((group) => (group.hooks ?? []).map((hook) => hook.command ?? '')));
176
+ /** Arquivo do projeto com o nome do agent não conta: o update o preserva, e o aviso nunca sairia. */
177
+ function checkMissingHarnessAgents(root, lock) {
178
+ const catalog = loadCatalog();
179
+ const faltando = agentsForaDoLock(catalog, lock).filter((id) => (itemSources(catalog, 'agent', id) ?? []).some(({ path }) => !existsSync(join(root, path))));
180
+ if (!faltando.length)
181
+ return [];
182
+ return [
183
+ {
184
+ id: 'agent-harness-faltando',
185
+ severidade: 'aviso',
186
+ mensagem: `Agents do harness que esta instalação ainda não recebeu: ${faltando.join(', ')}.`,
187
+ correcao: 'Rode `npx @fontdata/ai-harness update --yes`.',
188
+ },
189
+ ];
177
190
  }
178
191
  function checkSettings(root) {
179
192
  const file = join(root, SETTINGS_PATH);
@@ -241,6 +254,16 @@ function checkGitIgnore(root) {
241
254
  },
242
255
  ];
243
256
  }
257
+ function checkDelphiRes(root) {
258
+ return classificarRes(root)
259
+ .filter((res) => res.classe !== 'manter')
260
+ .map((res) => ({
261
+ id: 'delphi-res-versionado',
262
+ severidade: 'aviso',
263
+ mensagem: `${res.caminho} está versionado e é ${res.classe}: ${res.motivo}`,
264
+ correcao: 'Rode a etapa `/harness ignores` para classificar, extrair o ícone se preciso e tirar o .res do versionamento com aprovação.',
265
+ }));
266
+ }
244
267
  function checkWorks(root) {
245
268
  return validateAllWorks(root).map((problem) => ({
246
269
  id: `contrato-${problem.regra}`,
@@ -499,10 +522,10 @@ function checkOldCommentsBlock(root) {
499
522
  }
500
523
  /**
501
524
  * Lock anterior ao padrão de comentários e sem a recusa no config: o update o instala. Hook no disco fora do lock é
502
- * instalação antiga ou adaptada, que o update só registra no lock.
525
+ * instalação antiga ou adaptada, que o update só registra no lock. Outro hook registrado no settings é do projeto.
503
526
  */
504
527
  function checkComments(root, lock, config) {
505
- if (!config.comentarios.instalar || existsSync(join(root, COMMENTS_HOOK_PATH)))
528
+ if (!config.comentarios.instalar || existsSync(join(root, COMMENTS_HOOK_PATH)) || hookProprioRegistrado(root))
506
529
  return [];
507
530
  if (lock.itens.some((item) => item.tipo === 'hook' && item.id === 'comentarios'))
508
531
  return [];
@@ -632,12 +655,13 @@ export function runDoctor(root, options = {}) {
632
655
  return [
633
656
  ...checkNode(options.nodeVersion ?? process.versions.node),
634
657
  ...lockFindings,
635
- ...(lock ? [...checkFiles(root, lock), ...checkRequiredSkills(root, lock), ...checkComments(root, lock, config)] : []),
658
+ ...(lock ? [...checkFiles(root, lock), ...checkRequiredSkills(root, lock), ...checkMissingHarnessAgents(root, lock), ...checkComments(root, lock, config)] : []),
636
659
  ...checkShadowedCommands(root),
637
660
  ...checkOldCommentsBlock(root),
638
661
  ...checkAgents(root),
639
662
  ...checkSettings(root),
640
663
  ...checkGitIgnore(root),
664
+ ...checkDelphiRes(root),
641
665
  ...checkConfig(configProblems),
642
666
  ...checkBanco(root, config),
643
667
  ...checkWorks(root),
package/dist/init.js CHANGED
@@ -104,6 +104,7 @@ function runNonInteractive(args) {
104
104
  throw new Error(`Pasta não encontrada: ${repoPath}`);
105
105
  readLock(repoPath);
106
106
  const options = resolveInstallOptions(args);
107
+ options.comments = args.comments ?? readConfig(repoPath).config.comentarios.instalar;
107
108
  const skippedForPlugin = options.hooks && isHarnessPluginEnabled(repoPath);
108
109
  if (skippedForPlugin)
109
110
  options.hooks = false;
@@ -212,7 +213,7 @@ async function runWizard(args) {
212
213
  }));
213
214
  const comments = bail(await p.confirm({
214
215
  message: 'Instalar o padrão de comentários (rule, hook que bloqueia a violação e catraca do legado)?',
215
- initialValue: true,
216
+ initialValue: readConfig(repoPath).config.comentarios.instalar,
216
217
  }));
217
218
  const options = {
218
219
  scope: scope === 'all' ? 'all' : scope === 'manual' ? 'manual' : 'recommended',
@@ -8,7 +8,7 @@ import { HOOKS_ITEM_ID, PROJECT_HOOKS_DIR, projectHooksConfig } from './hooks.js
8
8
  import { neededSkillsFor, resolveSelection } from './selection.js';
9
9
  import { BANCO_MCP_NOME, bancoMcpServer, MCP_PATH, mergeMcpServers } from './mcp.js';
10
10
  import { gravarInstalarComentarios, gravarRegistrarMcp } from '../config/config.js';
11
- import { COMMENTS_RULE_PATH, commentsHooksConfig, ensureCommentsBaseline } from '../comentarios/instalar.js';
11
+ import { COMMENTS_RULE_PATH, commentsHooksConfig, ensureCommentsBaseline, hookProprio, hookProprioRegistrado } from '../comentarios/instalar.js';
12
12
  import { combineHooks, HARNESS_DENY, harnessPermissions, mergeSettings } from './settings.js';
13
13
  /** Rule de convenção com o que é específico do projeto (D-38): é do projeto, então fica fora do lock. */
14
14
  export const PROJECT_RULE_PATH = '.claude/rules/harness-projeto.md';
@@ -81,6 +81,13 @@ export function itemSources(catalog, tipo, id) {
81
81
  }
82
82
  return null;
83
83
  }
84
+ /** Agents do catálogo que o lock não tem. Lock sem nenhum agent é a recusa do `--sem-agents`: nada falta. */
85
+ export function agentsForaDoLock(catalog, lock) {
86
+ const noLock = new Set(lock.itens.filter((item) => item.tipo === 'agent').map((item) => item.id));
87
+ if (!noLock.size)
88
+ return [];
89
+ return (catalog.agents ?? []).map((agent) => agent.id).filter((id) => !noLock.has(id));
90
+ }
84
91
  function selectCommands(catalog, options) {
85
92
  if (options.scope === 'all')
86
93
  return allCommands(catalog);
@@ -100,6 +107,9 @@ export function planInstall(catalog, root, options) {
100
107
  const wantMaster = options.includeMaster || options.commands.includes(catalog.master.id);
101
108
  const { selected, autoAdded } = resolveSelection(catalog, selectCommands(catalog, options), wantMaster);
102
109
  const alteradosLocalmente = [];
110
+ const itensNoLock = readLock(root)?.itens ?? [];
111
+ const hookNoLock = itensNoLock.some((item) => item.tipo === 'hook' && item.id === 'comentarios');
112
+ const comentariosDoProjeto = Boolean(options.comments) && ((!hookNoLock && hookProprio(root)) || hookProprioRegistrado(root));
103
113
  const plan = {
104
114
  files: [],
105
115
  skipped: [],
@@ -107,11 +117,12 @@ export function planInstall(catalog, root, options) {
107
117
  autoAdded,
108
118
  claudeMdBackup: false,
109
119
  registerHooks: Boolean(options.hooks),
110
- registerComments: Boolean(options.comments),
120
+ registerComments: Boolean(options.comments) && !comentariosDoProjeto,
111
121
  comentariosRecusados: !options.comments,
122
+ comentariosDoProjeto,
112
123
  alteradosLocalmente,
113
124
  };
114
- const hashNoLock = new Map((readLock(root)?.itens ?? []).flatMap((item) => item.arquivos.map((a) => [a.caminho, a.sha256])));
125
+ const hashNoLock = new Map(itensNoLock.flatMap((item) => item.arquivos.map((a) => [a.caminho, a.sha256])));
115
126
  const add = (tipo, id) => {
116
127
  const paths = [];
117
128
  for (const entry of itemSources(catalog, tipo, id) ?? []) {
@@ -149,7 +160,7 @@ export function planInstall(catalog, root, options) {
149
160
  if (options.agents)
150
161
  for (const agent of catalog.agents ?? [])
151
162
  add('agent', agent.id);
152
- if (options.comments) {
163
+ if (plan.registerComments) {
153
164
  add('rule', 'comentarios');
154
165
  add('hook', 'comentarios');
155
166
  }
@@ -192,7 +203,7 @@ export function executePlan(root, plan, pkg, now = new Date()) {
192
203
  gravarRegistrarMcp(root, false);
193
204
  if (plan.comentariosRecusados)
194
205
  gravarInstalarComentarios(root, false);
195
- else if (plan.registerComments)
206
+ else if (plan.registerComments || plan.comentariosDoProjeto)
196
207
  gravarInstalarComentarios(root, true);
197
208
  const items = new Map();
198
209
  for (const item of previous?.itens ?? [])
@@ -260,5 +271,8 @@ export function describePlan(plan) {
260
271
  else if (plan.comentariosRecusados) {
261
272
  lines.push(`Padrão de comentários não instalado (recusado); a escolha fica em comentarios.instalar: false no .ai-harness/config.json, e o update a respeita.`);
262
273
  }
274
+ else if (plan.comentariosDoProjeto) {
275
+ lines.push('Padrão de comentários mantido como está: o projeto já tem hook próprio em .claude/hooks/comentarios/, e o do pacote não foi instalado nem registrado.');
276
+ }
263
277
  return lines.join('\n');
264
278
  }
@@ -93,13 +93,21 @@ export function hasAllowRule(root, rule, key = 'allow') {
93
93
  return false;
94
94
  }
95
95
  }
96
+ /** Comandos de todos os hooks, sem assumir que o `settings.json` do projeto está bem formado. */
97
+ export function hookCommands(hooks) {
98
+ return Object.values(hooks).flatMap((groups) => (Array.isArray(groups) ? groups : []).flatMap((group) => (group.hooks ?? []).map((hook) => hook.command ?? '')));
99
+ }
100
+ /** Mesma forma para `$CLAUDE_PROJECT_DIR` e `${CLAUDE_PROJECT_DIR}`, que o shell expande igual. */
101
+ export function normalizarComandoHook(command) {
102
+ return command.replace(/\$CLAUDE_PROJECT_DIR\b/g, '${CLAUDE_PROJECT_DIR}');
103
+ }
96
104
  export function mergeHooksIntoSettings(root, hooks, now = new Date()) {
97
105
  return mergeSettings(root, { hooks }, now);
98
106
  }
99
107
  /**
100
108
  * Acrescenta hooks e regras de `permissions.allow` ao `.claude/settings.json` do projeto
101
109
  * sem perder o que já existe. Um hook é considerado presente quando algum grupo do mesmo
102
- * evento já tem o mesmo `command`, e uma regra quando já está na lista, o que torna a
110
+ * evento já tem o mesmo `command`, nas duas grafias de `CLAUDE_PROJECT_DIR`, e uma regra quando já está na lista, o que torna a
103
111
  * operação idempotente. As regras de `removeAllow` saem de `permissions.allow`. Tudo é gravado de uma vez, com um único backup datado do arquivo
104
112
  * original; JSON inválido é recusado sem tocar em nada.
105
113
  */
@@ -135,14 +143,14 @@ export function mergeSettings(root, additions, now = new Date()) {
135
143
  const merged = { ...(settings.hooks ?? {}) };
136
144
  for (const [event, groups] of hookEntries) {
137
145
  const eventGroups = [...(merged[event] ?? [])];
138
- const known = new Set(eventGroups.flatMap((group) => group.hooks.map((hook) => hook.command)));
146
+ const known = new Set(hookCommands({ [event]: eventGroups }).map(normalizarComandoHook));
139
147
  for (const group of groups) {
140
- const missing = group.hooks.filter((hook) => !known.has(hook.command));
148
+ const missing = group.hooks.filter((hook) => !known.has(normalizarComandoHook(hook.command)));
141
149
  if (!missing.length)
142
150
  continue;
143
151
  eventGroups.push({ ...group, hooks: missing });
144
152
  for (const hook of missing)
145
- known.add(hook.command);
153
+ known.add(normalizarComandoHook(hook.command));
146
154
  changed = true;
147
155
  }
148
156
  merged[event] = eventGroups;
@@ -1,14 +1,14 @@
1
1
  import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
2
2
  import { dirname, join, resolve } from 'node:path';
3
- import { allCommands, loadCatalog, templatesDir } from '../catalog.js';
4
- import { COMMENTS_HOOK_PATH, commentsHooksConfig, ensureCommentsBaseline } from '../comentarios/instalar.js';
3
+ import { allCommands, loadCatalog } from '../catalog.js';
4
+ import { COMMENTS_HOOK_PATH, COMMENTS_HOOK_TEMPLATE, commentsHooksConfig, ensureCommentsBaseline, hookProprio, hookProprioRegistrado } from '../comentarios/instalar.js';
5
5
  import { CONFIG_PATH, gravarInstalarComentarios, gravarRegistrarMcp, migrarSecaoBanco, readConfig, syncGitignore, temSecaoBancoLegada, writeDefaultConfig, } from '../config/config.js';
6
6
  import { applyAtomically } from '../install/atomic.js';
7
7
  import { suggestFlag } from '../install/flags.js';
8
8
  import { HOOKS_ITEM_ID, isHarnessPluginEnabled, projectHooksConfig } from '../install/hooks.js';
9
9
  import { BANCO_MCP_NOME, BANCO_MCP_NOME_LEGADO, bancoMcpServer, ehEntradaGerenciada, MCP_PATH, mergeMcpServers } from '../install/mcp.js';
10
10
  import { hashContent, LOCK_PATH, LOCK_VERSION, readLock, writeLock } from '../install/lock.js';
11
- import { itemSources, packageInfo, PROJECT_RULE_PATH, projectRuleContent } from '../install/plan.js';
11
+ import { agentsForaDoLock, itemSources, packageInfo, PROJECT_RULE_PATH, projectRuleContent } from '../install/plan.js';
12
12
  import { neededSkillsFor } from '../install/selection.js';
13
13
  import { BANCO_PERMISSIONS_LEGADAS, combineHooks, HARNESS_DENY, harnessPermissions, hasAllowRule, mergeSettings, SETTINGS_PATH, } from '../install/settings.js';
14
14
  import { adoptLegacyInstall } from './legado.js';
@@ -50,12 +50,6 @@ function legacyPath(root, path) {
50
50
  return candidate;
51
51
  }
52
52
  }
53
- const COMMENTS_HOOK_TEMPLATE = join(templatesDir, 'hooks', 'comentarios', 'check.mjs');
54
- /** O hook de comentários existe no projeto com conteúdo diferente do template do pacote. */
55
- function hookProprio(root) {
56
- const local = join(root, COMMENTS_HOOK_PATH);
57
- return existsSync(local) && hashContent(readFileSync(local)) !== hashContent(readFileSync(COMMENTS_HOOK_TEMPLATE));
58
- }
59
53
  export function checkUpdate(root, catalog = loadCatalog(), legacy, home, { semBanco = false, semComentarios = false } = {}) {
60
54
  const recorded = readLock(root);
61
55
  const lock = recorded ?? adoptLegacyInstall(root, legacy);
@@ -145,12 +139,14 @@ export function checkUpdate(root, catalog = loadCatalog(), legacy, home, { semBa
145
139
  if (!pluginHooks)
146
140
  addItem('hook', HOOKS_ITEM_ID, true);
147
141
  }
142
+ for (const id of agentsForaDoLock(catalog, lock))
143
+ addItem('agent', id, true);
148
144
  // O padrão de comentários também chega ao lock anterior a ele, salvo com a recusa no config ou na flag. O hook é a
149
145
  // referência: o comando `comentarios` não registra a rule quando o projeto já tem uma própria.
150
146
  const querComentarios = !semComentarios && config.comentarios.instalar;
151
147
  const hookNoLock = trackedItems.has('hook:comentarios');
152
148
  const registrarHookComentarios = querComentarios && !hookNoLock && hookProprio(root);
153
- const registrarComentarios = querComentarios && !registrarHookComentarios && (adotada || !hookNoLock);
149
+ const registrarComentarios = querComentarios && !registrarHookComentarios && !hookProprioRegistrado(root) && (adotada || !hookNoLock);
154
150
  if (registrarComentarios) {
155
151
  addItem('rule', 'comentarios', true);
156
152
  addItem('hook', 'comentarios', true);
@@ -36,7 +36,8 @@ export function extratorParaTexto(cfg) {
36
36
  function juntar(base, nome) {
37
37
  return base ? `${base}/${nome}` : nome;
38
38
  }
39
- function varrer(raiz, base, profundidade) {
39
+ /** Caminhos (com `/`, relativos à raiz) dos arquivos cujo nome casa com `casa`: os do nível antes das subpastas. */
40
+ export function varrerArquivos(raiz, base, profundidade, casa) {
40
41
  let entradas;
41
42
  try {
42
43
  entradas = readdirSync(join(raiz, base), { withFileTypes: true });
@@ -47,21 +48,26 @@ function varrer(raiz, base, profundidade) {
47
48
  entradas.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
48
49
  const achados = [];
49
50
  for (const e of entradas) {
50
- if (e.isFile()) {
51
- const candidato = CANDIDATOS.find((c) => c.casa.test(e.name));
52
- for (const extrator of candidato?.extratores ?? [])
53
- achados.push({ caminho: juntar(base, e.name), extrator });
54
- }
51
+ if (e.isFile() && casa.test(e.name))
52
+ achados.push(juntar(base, e.name));
55
53
  }
56
54
  if (profundidade > 0) {
57
55
  for (const e of entradas) {
58
56
  if (e.isDirectory() && !e.name.startsWith('.') && !PASTAS_IGNORADAS.has(e.name)) {
59
- achados.push(...varrer(raiz, juntar(base, e.name), profundidade - 1));
57
+ achados.push(...varrerArquivos(raiz, juntar(base, e.name), profundidade - 1, casa));
60
58
  }
61
59
  }
62
60
  }
63
61
  return achados;
64
62
  }
63
+ const CASA_CANDIDATO = new RegExp(CANDIDATOS.map((c) => `(?:${c.casa.source})`).join('|'), 'i');
64
+ function varrer(raiz, base, profundidade) {
65
+ return varrerArquivos(raiz, base, profundidade, CASA_CANDIDATO).flatMap((caminho) => {
66
+ const nome = caminho.slice(caminho.lastIndexOf('/') + 1);
67
+ const candidato = CANDIDATOS.find((c) => c.casa.test(nome));
68
+ return (candidato?.extratores ?? []).map((extrator) => ({ caminho, extrator }));
69
+ });
70
+ }
65
71
  function lerFontes(raiz, arquivos, problemas) {
66
72
  return arquivos.map((arquivo) => {
67
73
  const fonte = { caminho: arquivo.caminho, extrator: arquivo.extrator, ocorrencias: [] };
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@fontdata/ai-harness",
3
- "version": "4.1.0",
3
+ "version": "4.2.0",
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": {
@@ -33,6 +33,41 @@ Versão reforçada cobrindo as mesmas categorias. Se já existir, **reconcilie**
33
33
  que o projeto já tem. Mantenha versionados `.ai-harness/` e `.claude/`; o rastro em `docs/eventos/` fica fora do
34
34
  versionamento por padrão.
35
35
 
36
+ ## Stack Delphi
37
+
38
+ A stack é Delphi quando há `*.dproj` ou `*.dpr`; confirme com `npx @fontdata/ai-harness delphi classificar`. O
39
+ projeto é **novo** quando `delphi classificar` não lista nenhum `.res` rastreado, e **existente** quando lista algum.
40
+
41
+ **Projeto novo.** Inclua no `.gitignore` os padrões `*.res`, `*.dres`, `__history/`, `__recovery/`, `*.dcu`,
42
+ `*.local`, `*.identcache`, `*.stat`, `*.dsk`, as pastas `Win32/` e `Win64/` e o `Thumbs.db`. Um `.res` feito à mão
43
+ é o que não tem `.dpr` nem `.dproj` de mesmo nome na pasta: pergunte ao usuário se ele deve ser versionado e, com o
44
+ sim, acrescente a exceção `!caminho/Arquivo.res`.
45
+
46
+ **Projeto existente.** Antes de ignorar, rode `delphi classificar` e mostre a tabela ao usuário. Por classe:
47
+
48
+ - `regeravel`: sai do versionamento, porque a IDE o regera.
49
+ - `icone-so-no-res`: proponha `delphi extrair-icone <arquivo.res>`, que grava `<Projeto>_Icon.ico` ao lado do
50
+ `.res`, e troque no `.dproj` só os `Icon_MainIcon` próprios, deixando intactos os valores `$(BDS)\...`. Sem isso,
51
+ o executável perde o ícone.
52
+ - `manter`: continua versionado. Ocorre em projeto sem `.dproj` (Delphi antigo), em `.res` com recurso próprio que
53
+ a IDE não regera, em biblioteca de terceiros marcada `linguist-vendored` no `.gitattributes`, em pacote (`.dpk`)
54
+ e em `.res` ilegível.
55
+
56
+ Os demais padrões entram como no projeto novo. Um `.dres` já rastreado fica como está. A linha do `.res` no
57
+ `.gitignore` depende da tabela: com algum `manter`, o caminho exato de cada `.res` removido, para que um `.res` novo
58
+ com recurso próprio não seja ignorado sem ninguém perceber; sem nenhum `manter`, `*.res`.
59
+
60
+ **Remoção.** Faz parte do 🚦 da etapa: só depois da aprovação. Com o stage limpo, rode `git rm --cached <arquivo>`
61
+ de cada `.res` e depois `git commit` sem pathspec. Não use `git commit -- <caminho>`: com o arquivo ainda no disco,
62
+ ele readiciona ao índice o `.res` removido.
63
+
64
+ **Ícone.** Fica dentro da pasta do projeto, com caminho relativo no `.dproj`. Ao copiar o `.dproj` de outro projeto,
65
+ troque o ícone.
66
+
67
+ **Por quê.** O `.res` principal tem só VERSIONINFO, `MAINICON`, MANIFEST e `PLATFORMTARGETS`, e a IDE o regera a
68
+ partir do `.dproj`. Versionado, vira diff binário a cada bump de versão e conflito de merge. O `.dres` também é
69
+ gerado, a partir dos `RcItem` do `.dproj`; versionados ficam os arquivos de origem.
70
+
36
71
  ## Regras
37
72
 
38
73
  - Seja conservador: em caso de dúvida, exclua.