@elia97/officina 0.6.0 → 0.7.0

package/README.md

@@ -44,7 +44,7 @@ I gate leggono dalla cartella corrente, che deve essere la radice del repository
 | `check smoke [url]` | la produzione viva: pagine, header di sicurezza, BotID, host canonico, barra finale | `src/pages`, più le rotte non HTML |
 | `check analytics [GTM-…]` | il container GTM pubblico contro gli eventi del modulo di link-tracking del progetto (`analytics.linkTracking`) | — |
 | `check lighthouse [--local]` | Lighthouse CI sul `.lighthouserc.json` del progetto; `--local` fa build, server e Chrome da sé | `src/pages` |
-| `gen icons` | le icone del manifest, disegnate dal favicon SVG in `public/` del progetto | — |
+| `gen icons` | le icone del manifest, disegnate da `public/favicon.svg`, che è il suo ingresso obbligatorio | — |
 
 Il motore è uguale per tutti; ciò che cambia da un progetto all'altro sta in un file solo, `officina.config.ts` nella radice:
 
@@ -79,11 +79,13 @@ La radice del pacchetto esporta `defineConfig` e i tipi; i pezzi del motore stan
 
 `features` dice quali controlli il progetto pretende: `'required'` fa fallire il gate quando ciò che deve guardare non c'è, `false` lo spegne dicendolo. Una voce non dichiarata vale `'required'`, e `doctor` la segnala: un gate che esce 0 su un container GTM che non esiste non afferma niente. `routes.representatives` dà a ogni pattern dinamico di `src/pages` un percorso vero, e da lì smoke e Lighthouse guardano anche quelle pagine.
 
+`features.generators` ha un valore in più delle altre due, perché non tutti i siti in produzione nascono dallo scaffold: `'required'` è il comportamento di sempre; `false` spegne i generatori del pacchetto, e `doctor` smette di chiedere i punti di aggancio e gli ancoraggi invece di pretendere file che nessun codice di quel sito userebbe; `'project'` fa lo stesso ma lascia vivi i generatori che il progetto scrive in `officina.generators.mjs`, che a quel punto `doctor` pretende. Con `false` o `'project'`, `officina gen section|page|component|collection` si ferma dicendolo, mentre gli script `gen` e `gen:*` restano attesi in `package.json`: meglio un comando che spiega di uno script che manca. `gen icons` non c'entra con i generatori di codice e non cambia.
+
 `placeholders` dice a `check placeholders` cosa guardare: `sources` sono i file da scandire, `contactEnvKeys` le variabili che `--env` pretende. Una lista dichiarata **sostituisce** quella del pacchetto, dizionari compresi: senza dichiarazione i sorgenti sono `src/lib/site.ts`, `src/lib/company.ts` e i dizionari di `src/i18n/strings`, quando la cartella esiste. Serve ai progetti che non nascono dallo scaffold: se partita IVA, recapiti e destinatario dei form stanno nel contenuto invece che in un modulo, i sorgenti del template non sono i suoi, e crearli per far passare il gate terrebbe gli stessi dati in due sedi. Un sorgente elencato che non esiste è un ritrovamento con il suo percorso, non un errore che ferma il comando.
 
 Il file lo carica Node, che fuori da `node_modules` toglie i tipi da sé: niente `enum`, niente alias `@/`. Due file `officina.config.*` insieme sono un errore, come un file senza default export; il resto lo valida `loadConfig` a runtime, nominando il percorso della voce sbagliata — `bundle.cssMaxGzip: atteso un numero, ricevuto una stringa` — e una voce sconosciuta, perché `sitUrl` al posto di `siteUrl` non deve passare in silenzio.
 
-`sharp` è una dipendenza facoltativa del progetto, non del pacchetto: serve solo a `gen icons`, che senza lo dice ed esce 1. `@biomejs/biome` invece è una peer dependency con l'intervallo che il preset regge, e `doctor` confronta la versione del progetto con quello.
+`sharp` è una dipendenza facoltativa del progetto, non del pacchetto: serve solo a `gen icons`, che senza lo dice ed esce 1. Un ingresso che manca — il favicon, `.lighthouserc.json`, `src/pages`, la build in `dist/client` — è sempre una riga che nomina il file e dice a cosa serve, mai uno stack trace. `@biomejs/biome` invece è una peer dependency con l'intervallo che il preset regge, e `doctor` confronta la versione del progetto con quello.
 
 ## Preset di configurazione
 
@@ -140,6 +142,8 @@ Perché le action non restino ferme per sempre, Dependabot di questo repository
 
 `officina doctor` dice, in qualunque repository, cosa manca perché il progetto prenda tutto da fuori: i punti di aggancio dei generatori, gli ancoraggi delle pagine a sezioni e dei dizionari, gli script, le dipendenze e gli strumenti di `package.json`, i residui di ciò che è uscito (copia del metodo, script, documenti commerciali), i preset, i workflow di GitHub e Dependabot, `officina.config.ts`. Sta dentro `ci`, quindi un progetto allineato non torna indietro senza che il gate lo dica.
 
+Di `.github/dependabot.yml` guarda la **forma**, non la presenza delle chiavi: lo legge come YAML e pretende che le chiavi del gruppo stiano sul gruppo — Dependabot rifiuta l'intero file se `commit-message` o `open-pull-requests-limit` stanno su una voce che dichiara `multi-ecosystem-group` — e che ogni ecosistema del gruppo abbia una seconda voce per il resto. Senza quella, `patterns` restringe l'intera voce e tutto il resto smette di aggiornarsi senza che niente diventi rosso.
+
 Le prime due sezioni rispondono a due domande diverse. I punti di aggancio sono l'elenco di `src/lib/contract.ts`, e chiedono che una cosa esista: i moduli che il codice generato importa, le cartelle in cui i generatori scrivono, `class-variance-authority` fra le dipendenze, lo script `check` che il post-gen lancia. Gli ancoraggi guardano dentro quei file, e chiedono che abbiano ancora la forma su cui l'iniezione conta:
 
 - per ogni collection a sezioni registrata in `src/content.config.ts` — riconosciuta dall'import di `<nome>CollectionSchema` da `@/lib/schemas/<nome>`, non dai marcatori, che sono proprio ciò che può sparire — la funzione `<nome>CollectionSchema`, la sua `z.discriminatedUnion` sopra un array letterale, il parametro non destrutturato che una sezione con immagine riceve, il `return { … }` di primo livello di `get<Nome>Sections`, e una sola pagina sotto `src/pages/` che porti `{/* @gen:<nome>-sections */}` e, su quella, `// @gen:<nome>-imports`;

package/dist/checks/analytics.js

@@ -4,6 +4,7 @@
 import { readFileSync } from 'node:fs';
 import process from 'node:process';
 import { coverageOf, extractLinkEvents } from '../lib/analytics-coverage.js';
+import { missingInput } from '../lib/cli.js';
 import { isRequired, loadConfig } from '../lib/config.js';
 import { extractTriggers, googleTagIds, parseContainerData } from '../lib/gtm-container.js';
 const LINK_TRACKING = 'src/lib/analytics/link-tracking.ts';
@@ -37,6 +38,9 @@ export async function main(args = []) {
             '  oppure dichiara `features.analytics: false` se il progetto non ha analytics.\n');
         return 1;
     }
+    const linkTracking = analytics.linkTracking ?? LINK_TRACKING;
+    if (missingInput(linkTracking, 'è il modulo da cui si leggono gli eventi; `analytics.linkTracking` dice dove sta'))
+        return 1;
     const response = await fetch(`https://www.googletagmanager.com/gtm.js?id=${gtmId}`, {
         signal: AbortSignal.timeout(TIMEOUT_MS),
     });
@@ -45,7 +49,7 @@ export async function main(args = []) {
         return 1;
     }
     const container = parseContainerData(await response.text());
-    const source = readFileSync(analytics.linkTracking ?? LINK_TRACKING, 'utf8');
+    const source = readFileSync(linkTracking, 'utf8');
     const coverage = coverageOf(extractLinkEvents(source), extractTriggers(container));
     console.log(`\nGTM ${gtmId} — ID di misurazione: ${googleTagIds(container).join(', ') || '—'}\n`);
     return reportCoverage(coverage);

package/dist/checks/bundle.js

@@ -5,6 +5,7 @@ import { join } from 'node:path';
 import process from 'node:process';
 import { gzipSync } from 'node:zlib';
 import { budgetFor, CSS_BUDGET_GZIP, cssBudgetFailure, deferredClosure, heaviestStylesheet, htmlEntries, parseEdges, staticClosure, } from '../lib/bundle-budget.js';
+import { missingInput } from '../lib/cli.js';
 import { loadConfig } from '../lib/config.js';
 import { expectedRoutes, filesWithExtension, missingRouteFailures, readPageFiles, routeOf, } from '../lib/routes.js';
 const DIST = 'dist/client';
@@ -82,6 +83,10 @@ function printSsrNote(expected) {
 }
 export async function main() {
     const { bundle = {} } = await loadConfig(process.cwd());
+    if (missingInput(ASSETS, 'è la build da misurare: prima `pnpm build`'))
+        return 1;
+    if (missingInput(PAGES, 'le rotte attese si derivano da lì'))
+        return 1;
     const cssMaxGzip = bundle.cssMaxGzip ?? CSS_BUDGET_GZIP;
     const pages = measurePages(readChunks(), bundle.budgets ?? []);
     const expected = expectedRoutes(readPageFiles(PAGES), PAGES);

package/dist/checks/doctor.js

@@ -2,17 +2,19 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import process from 'node:process';
+import { PROJECT_GENERATORS } from '../gen/plopfile.mjs';
 import { dependencyGaps, leftoverGaps, presetGaps, scriptGaps, } from '../lib/alignment.js';
 import { anchorGaps } from '../lib/anchors.js';
 import { cliOptions, exitCode, printFindings } from '../lib/cli.js';
-import { findConfigFile, loadConfig } from '../lib/config.js';
+import { findConfigFile, generatorsSetting, loadConfig, } from '../lib/config.js';
 import { configGaps } from '../lib/config-gaps.js';
 import { contractGaps } from '../lib/contract.js';
+import { dependabotGaps } from '../lib/dependabot.js';
 import { trackedAndUntracked } from '../lib/git.js';
 import { expectedRoutes, missingRepresentatives, readPageFiles } from '../lib/routes.js';
 import { toolingGaps } from '../lib/tooling.js';
 import { packageVersion } from '../lib/versions.js';
-import { dependabotGaps, workflowGaps } from '../lib/workflows.js';
+import { workflowGaps } from '../lib/workflows.js';
 const PAGES = 'src/pages';
 function projectFiles(root) {
     return {
@@ -38,6 +40,30 @@ async function loadedConfig(root) {
         return error instanceof Error ? error : new Error(String(error));
     }
 }
+const HOOK_POINTS = 'punti di aggancio dei generatori';
+const ANCHORS = 'ancoraggi delle pagine a sezioni e dei dizionari';
+const usable = (config) => config === undefined || config instanceof Error ? {} : config;
+function generatorSections(root, setting) {
+    if (setting === 'required') {
+        return [
+            { title: HOOK_POINTS, gaps: contractGaps(root) },
+            { title: ANCHORS, gaps: anchorGaps(root) },
+        ];
+    }
+    const off = `\`features.generators: ${setting === false ? 'false' : "'project'"}\``;
+    if (setting === false)
+        return [
+            { title: HOOK_POINTS, off },
+            { title: ANCHORS, off },
+        ];
+    const missing = existsSync(join(root, PROJECT_GENERATORS))
+        ? []
+        : [{ path: PROJECT_GENERATORS, message: "manca: con `generators: 'project'` i generatori sono i suoi" }];
+    return [
+        { title: HOOK_POINTS, gaps: missing },
+        { title: ANCHORS, off },
+    ];
+}
 function orphanPatterns(root, config) {
     const pages = join(root, PAGES);
     if (!existsSync(pages) || config === undefined || config instanceof Error)
@@ -51,20 +77,27 @@ export async function main() {
     const version = packageVersion();
     const config = await loadedConfig(root);
     const sections = [
-        ['punti di aggancio dei generatori', contractGaps(root)],
-        ['ancoraggi delle pagine a sezioni e dei dizionari', anchorGaps(root)],
-        [
-            'script, dipendenze e strumenti di package.json',
-            [...scriptGaps(manifest), ...dependencyGaps(manifest), ...toolingGaps(manifest)],
-        ],
-        ['residui di ciò che è uscito dal repository', leftoverGaps(files)],
-        ['preset di configurazione', presetGaps(files)],
-        ['workflow di GitHub e Dependabot', [...workflowGaps(files, version), ...dependabotGaps(files)]],
-        ['officina.config.ts', configGaps(config, orphanPatterns(root, config))],
+        ...generatorSections(root, generatorsSetting(usable(config))),
+        {
+            title: 'script, dipendenze e strumenti di package.json',
+            gaps: [...scriptGaps(manifest), ...dependencyGaps(manifest), ...toolingGaps(manifest)],
+        },
+        { title: 'residui di ciò che è uscito dal repository', gaps: leftoverGaps(files) },
+        { title: 'preset di configurazione', gaps: presetGaps(files) },
+        {
+            title: 'workflow di GitHub e Dependabot',
+            gaps: [...workflowGaps(files, version), ...dependabotGaps(files)],
+        },
+        { title: 'officina.config.ts', gaps: configGaps(config, orphanPatterns(root, config)) },
     ];
     console.log(`\nofficina doctor ${version} — cosa manca al progetto per prendere tutto da fuori\n`);
     const findings = [];
-    for (const [title, gaps] of sections) {
+    for (const section of sections) {
+        if ('off' in section) {
+            console.log(`  · ${section.title} — spento da ${section.off}`);
+            continue;
+        }
+        const { title, gaps } = section;
         console.log(gaps.length === 0 ? `  ✓ ${title}` : `  ${title}: ${gaps.length}`);
         const sectionFindings = gaps.map((gap) => ({ ...gap, severity: 'error' }));
         printFindings(sectionFindings, cliOptions([]).format);

package/dist/checks/lighthouse.js

@@ -5,6 +5,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
+import { missingInput } from '../lib/cli.js';
 import { loadConfig } from '../lib/config.js';
 import { lighthouseConfig } from '../lib/lighthouse.js';
 import { auditRoutes, expectedRoutes, readPageFiles } from '../lib/routes.js';
@@ -21,6 +22,10 @@ export async function main(args = []) {
     if (args.includes('--local'))
         return runLocal();
     const { routes: configured = {} } = await loadConfig(process.cwd());
+    if (missingInput(RC_FILE, 'è la configurazione di Lighthouse CI'))
+        return 1;
+    if (missingInput(PAGES_DIR, 'le rotte da visitare si derivano da lì'))
+        return 1;
     const rc = JSON.parse(readFileSync(RC_FILE, 'utf8'));
     const routes = auditRoutes(expectedRoutes(readPageFiles(PAGES_DIR), PAGES_DIR), configured.representatives);
     const resolved = lighthouseConfig(rc, routes, process.env);

package/dist/checks/smoke.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 // L'unico controllo che vede cosa serve davvero il bordo: i test del progetto fissano solo vercel.json.
 import process from 'node:process';
+import { missingInput } from '../lib/cli.js';
 import { loadConfig } from '../lib/config.js';
 import { expectedRoutes, readPageFiles, smokeRoutes } from '../lib/routes.js';
 import { runChecks, SECURITY_HEADERS, waitForAlias, } from '../lib/smoke-production.js';
@@ -40,6 +41,8 @@ export async function main(args = []) {
         siteUrl,
         securityHeaders: smoke.securityHeaders ?? SECURITY_HEADERS,
     };
+    if (missingInput(PAGES_DIR, 'le rotte da visitare si derivano da lì'))
+        return 1;
     const expected = expectedRoutes(readPageFiles(PAGES_DIR), PAGES_DIR);
     const pages = smokeRoutes(expected, smoke.nonHtmlRoutes, routes.representatives);
     console.log(`\nSmoke di produzione — ${baseUrl}\n`);

package/dist/gen/icons.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import process from 'node:process';
+import { missingInput } from '../lib/cli.js';
 import { loadConfig } from '../lib/config.js';
+const FAVICON = 'public/favicon.svg';
 const isMissingSharp = (error) => error instanceof Error && 'code' in error && error.code === 'ERR_MODULE_NOT_FOUND' && error.message.includes('sharp');
 export async function main() {
     const { icons } = await loadConfig(process.cwd());
@@ -8,6 +10,8 @@ export async function main() {
         console.error('\n✗ officina.config.ts non dichiara icons.background: è il colore di fondo delle icone.\n');
         return 1;
     }
+    if (missingInput(FAVICON, 'è il disegno da cui officina ricava i PNG del manifest'))
+        return 1;
     try {
         // Caricato qui e non in testa: sharp è del progetto, e chi non genera icone non lo deve avere.
         const { writeIcons } = await import('../lib/icons.js');

package/dist/gen/plopfile.mjs

@@ -18,10 +18,12 @@ import sectionGenerator from './section.mjs';
 // pacchetto: stessa firma di un plopfile, `export default function (plop)`.
 export const PROJECT_GENERATORS = 'officina.generators.mjs';
 export default async function (plop) {
-    sectionGenerator(plop);
-    pageGenerator(plop);
-    componentGenerator(plop);
-    collectionGenerator(plop);
+    if (process.env.OFFICINA_GENERATORS !== 'project') {
+        sectionGenerator(plop);
+        pageGenerator(plop);
+        componentGenerator(plop);
+        collectionGenerator(plop);
+    }
     const extension = join(process.cwd(), PROJECT_GENERATORS);
     if (!existsSync(extension))
         return;

package/dist/gen/run.d.ts

@@ -1,2 +1,2 @@
 export declare function plopCommand(args: string[], cwd: string): string[];
-export declare function main(args?: string[]): number;
+export declare function main(args?: string[]): Promise<number>;

package/dist/gen/run.js

@@ -3,6 +3,9 @@ import { createRequire } from 'node:module';
 import { dirname, join } from 'node:path';
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
+import { missingInput } from '../lib/cli.js';
+import { generatorsSetting, loadConfig } from '../lib/config.js';
+import { PROJECT_GENERATORS } from './plopfile.mjs';
 // plop risolve i template dalla cartella del plopfile e scrive in `--dest`: il plopfile sta nel
 // pacchetto, la destinazione è il progetto da cui si lancia il comando.
 export function plopCommand(args, cwd) {
@@ -11,7 +14,16 @@ export function plopCommand(args, cwd) {
     const plopfile = fileURLToPath(new URL('./plopfile.mjs', import.meta.url));
     return [plopBin, '--plopfile', plopfile, '--dest', cwd, ...args];
 }
-export function main(args = []) {
-    const result = spawnSync(process.execPath, plopCommand(args, process.cwd()), { stdio: 'inherit' });
+export async function main(args = []) {
+    const setting = generatorsSetting(await loadConfig(process.cwd()));
+    if (setting === false) {
+        console.error('\n✗ Il progetto ha spento i generatori con `features.generators: false`: quelli del pacchetto\n' +
+            '  scriverebbero codice che qui non si incastra.\n');
+        return 1;
+    }
+    if (setting === 'project' && missingInput(PROJECT_GENERATORS, "con `generators: 'project'` i generatori sono i suoi"))
+        return 1;
+    const env = setting === 'project' ? { ...process.env, OFFICINA_GENERATORS: 'project' } : process.env;
+    const result = spawnSync(process.execPath, plopCommand(args, process.cwd()), { stdio: 'inherit', env });
     return result.status ?? 1;
 }

package/dist/lib/action-manifests.d.ts

@@ -0,0 +1,9 @@
+import { type Hit } from './cli.ts';
+export interface Manifest {
+    path: string;
+    source: string;
+}
+export interface ManifestHit extends Hit {
+    path: string;
+}
+export declare function manifestFindings(manifests: readonly Manifest[]): ManifestHit[];

package/dist/lib/action-manifests.js

@@ -0,0 +1,25 @@
+import { readLines } from './cli.js';
+import { isLive } from './workflows.js';
+const EXPRESSION = /\$\{\{[^}]*\}\}/g;
+const DESCRIPTION = /^\s*description:/;
+const FORBIDDEN = ['secrets', 'needs', 'matrix'];
+const contextIn = (expression) => FORBIDDEN.find((name) => new RegExp(`(^|[^\\w.])${name}\\.`).test(expression));
+function lineFindings(text) {
+    const expressions = [...text.matchAll(EXPRESSION)];
+    if (expressions.length === 0)
+        return [];
+    if (DESCRIPTION.test(text)) {
+        return ['`description` non ammette espressioni: il runner la valuta e il manifesto non si carica'];
+    }
+    return expressions.flatMap(([expression]) => {
+        const context = contextIn(expression);
+        return context === undefined ? [] : [`\`${context}\` non è un contesto di una composite action: passalo come input`];
+    });
+}
+// Il runner valuta le espressioni del manifesto prima di eseguire qualunque passo: un contesto che una
+// composite action non conosce non è un valore vuoto, è un'action che non si carica.
+export function manifestFindings(manifests) {
+    return manifests.flatMap(({ path, source }) => readLines(source)
+        .filter(({ text }) => isLive(text))
+        .flatMap(({ n, text }) => lineFindings(text).map((message) => ({ path, line: n, message }))));
+}

package/dist/lib/cli.d.ts

@@ -17,6 +17,7 @@ export declare function cliOptions(args?: string[]): {
 };
 export type CliOptions = ReturnType<typeof cliOptions>;
 export declare const isGenerated: (path: string) => boolean;
+export declare function missingInput(path: string, purpose: string): boolean;
 export declare function scopedPaths(options: CliOptions, isScanned: (path: string) => boolean): string[];
 export declare function printFindings(findings: Finding[], format: string): void;
 export declare function exitCode(findings: Finding[], strict: boolean): number;

package/dist/lib/cli.js

@@ -22,6 +22,12 @@ export function cliOptions(args = process.argv.slice(2)) {
 // Un file generato non lo scrive nessuno, e il suo banner chiede di tenerlo fuori da linter e
 // formatter: una correzione ai suoi commenti sparirebbe alla prima rigenerazione.
 export const isGenerated = (path) => /\.gen\.[cm]?tsx?$/.test(path);
+export function missingInput(path, purpose) {
+    if (existsSync(path))
+        return false;
+    console.error(`\n✗ ${path} non c'è: ${purpose}.\n`);
+    return true;
+}
 export function scopedPaths(options, isScanned) {
     const candidates = options.diff ? changedFiles({ base: options.base, head: options.head }) : trackedAndUntracked();
     // ls-files elenca anche i file cancellati ma non ancora rimossi dall'indice.

package/dist/lib/config.d.ts

@@ -3,6 +3,7 @@ import type { Representatives, VerifiedRoute } from './routes.ts';
 import type { SmokeCheck } from './smoke-production.ts';
 /** `'required'` fa fallire il gate quando ciò che deve controllare non c'è; `false` lo spegne. */
 export type FeatureSetting = 'required' | false;
+export type GeneratorsSetting = FeatureSetting | 'project';
 export interface OfficinaConfig {
     /** L'apice di produzione, senza barra finale: lo usa `check smoke` quando non riceve un URL. */
     siteUrl?: string;
@@ -25,6 +26,7 @@ export interface OfficinaConfig {
     features?: {
         analytics?: FeatureSetting;
         roadmap?: FeatureSetting;
+        generators?: GeneratorsSetting;
     };
     placeholders?: {
         sources?: readonly string[];
@@ -35,10 +37,11 @@ export interface OfficinaConfig {
         representatives?: Representatives;
     };
 }
-export declare const FEATURES: readonly ['analytics', 'roadmap'];
+export declare const FEATURES: readonly ['analytics', 'roadmap', 'generators'];
 export type FeatureName = (typeof FEATURES)[number];
 /** Un controllo si spegne solo scrivendolo: il silenzio vale `'required'`. */
 export declare const isRequired: (config: OfficinaConfig, name: FeatureName) => boolean;
+export declare const generatorsSetting: (config: OfficinaConfig) => GeneratorsSetting;
 export declare const defineConfig: (config: OfficinaConfig) => OfficinaConfig;
 export declare const findConfigFile: (root: string) => string | undefined;
 export declare function loadConfig(root: string): Promise<OfficinaConfig>;

package/dist/lib/config.js

@@ -10,12 +10,14 @@ import { existsSync } from 'node:fs';
 import { basename, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { aFunction, aNumber, anArrayOf, aRecordOf, aShape, aString, aStringOrNull, oneOf } from './validate.js';
-export const FEATURES = ['analytics', 'roadmap'];
+export const FEATURES = ['analytics', 'roadmap', 'generators'];
 /** Un controllo si spegne solo scrivendolo: il silenzio vale `'required'`. */
 export const isRequired = (config, name) => (config.features?.[name] ?? 'required') === 'required';
+export const generatorsSetting = (config) => config.features?.generators ?? 'required';
 const budget = aShape({ label: aString, matches: aFunction, maxGzip: aNumber });
 const verifiedRoute = aShape({ path: aString, type: aString });
 const feature = oneOf("'required' oppure false", ['required', false]);
+const generators = oneOf("'required', 'project' oppure false", ['required', 'project', false]);
 const SHAPE = aShape({
     siteUrl: aString,
     icons: aShape({ background: aString }),
@@ -26,7 +28,7 @@ const SHAPE = aShape({
         checks: anArrayOf(aFunction),
     }),
     analytics: aShape({ linkTracking: aString }),
-    features: aShape({ analytics: feature, roadmap: feature }),
+    features: aShape({ analytics: feature, roadmap: feature, generators }),
     placeholders: aShape({ sources: anArrayOf(aString), contactEnvKeys: anArrayOf(aString) }),
     routes: aShape({ representatives: aRecordOf(aString) }),
 });

package/dist/lib/dependabot.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectFiles } from './alignment.ts';
+import type { ContractGap } from './contract.ts';
+export declare function dependabotGaps({ read: readFile }: ProjectFiles): ContractGap[];

package/dist/lib/dependabot.js

@@ -0,0 +1,59 @@
+import { parse } from 'yaml';
+const DEPENDABOT = '.github/dependabot.yml';
+const PACKAGE = '@elia97/officina';
+const ACTIONS = 'Elia97/officina/*';
+const GROUP_ONLY = ['commit-message', 'open-pull-requests-limit'];
+const gap = (message) => ({ path: DEPENDABOT, message });
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+function read(source) {
+    try {
+        const document = parse(source);
+        return isRecord(document) ? document : 'non è una mappa YAML';
+    }
+    catch (error) {
+        return `non è YAML valido: ${String(error).replace(/\n[\s\S]*$/, '')}`;
+    }
+}
+const inGroup = (updates) => updates.filter((u) => u['multi-ecosystem-group'] !== undefined);
+const covers = (update, needle) => (update.patterns ?? []).includes(needle);
+function groupGaps(document, updates) {
+    const groups = document['multi-ecosystem-groups'];
+    if (!isRecord(groups) || Object.keys(groups).length === 0) {
+        return [gap('non dichiara `multi-ecosystem-groups`: il pacchetto e le sue action si alzano separati')];
+    }
+    return inGroup(updates)
+        .filter((update) => !(update['multi-ecosystem-group'] in groups))
+        .map((update) => gap(`la voce \`${update['package-ecosystem']}\` cita il gruppo \`${update['multi-ecosystem-group']}\`, che non esiste`));
+}
+const misplacedGaps = (updates) => inGroup(updates).flatMap((update) => GROUP_ONLY.filter((key) => update[key] !== undefined).map((key) => gap(`\`${key}\` sta sulla voce \`${update['package-ecosystem']}\` del gruppo: va sul gruppo, e Dependabot rifiuta il file`)));
+const coverageGaps = (updates) => [
+    { ecosystem: 'npm', needle: PACKAGE, reason: 'il gruppo deve prendere il pacchetto da npm' },
+    { ecosystem: 'github-actions', needle: ACTIONS, reason: 'il gruppo deve prendere le action da github-actions' },
+]
+    .filter(({ ecosystem, needle }) => !inGroup(updates).some((u) => u['package-ecosystem'] === ecosystem && covers(u, needle)))
+    .map(({ needle, reason }) => gap(`nessuna voce del gruppo copre \`${needle}\`: ${reason}`));
+// `patterns` restringe l'intera voce: il resto dell'ecosistema smette di aggiornarsi e nessun check diventa rosso.
+function restGaps(updates) {
+    const restrained = inGroup(updates).filter((update) => (update.patterns ?? []).length > 0);
+    return restrained.flatMap((update) => {
+        const ecosystem = update['package-ecosystem'];
+        const rest = updates.find((other) => other['package-ecosystem'] === ecosystem && other['multi-ecosystem-group'] === undefined);
+        if (rest === undefined) {
+            return [gap(`\`${ecosystem}\` sta solo nella voce del gruppo, con \`patterns\`: il resto non si aggiorna più`)];
+        }
+        return rest['commit-message'] === undefined
+            ? [gap(`la voce \`${ecosystem}\` fuori dal gruppo non ha \`commit-message\`: le sue PR non passano il titolo`)]
+            : [];
+    });
+}
+export function dependabotGaps({ read: readFile }) {
+    const source = readFile(DEPENDABOT);
+    if (source === undefined) {
+        return [gap('manca: senza, il pacchetto e le sue action si alzano separati')];
+    }
+    const document = read(source);
+    if (typeof document === 'string')
+        return [gap(document)];
+    const updates = document.updates ?? [];
+    return [...groupGaps(document, updates), ...misplacedGaps(updates), ...coverageGaps(updates), ...restGaps(updates)];
+}

package/dist/lib/workflows.d.ts

@@ -1,6 +1,6 @@
 import type { ProjectFiles } from './alignment.ts';
 import type { ContractGap } from './contract.ts';
+export declare const isLive: (line: string) => boolean;
 export declare const mentions: (source: string | undefined, needle: string) => boolean;
 /** Le action del progetto devono stare alla stessa versione del pacchetto installato. */
 export declare function workflowGaps({ read }: ProjectFiles, version: string): ContractGap[];
-export declare function dependabotGaps({ read }: ProjectFiles): ContractGap[];

package/dist/lib/workflows.js

@@ -1,7 +1,7 @@
-// I workflow restano una ricerca testuale — non c'è un parser YAML nel pacchetto — ma una riga
-// commentata non deve soddisfare niente: è il modo più facile per avere un progetto «a posto»
-// che in CI non lancia nessuno di questi passi.
-const liveLines = (source) => source.split(/\r?\n/).filter((line) => !line.trimStart().startsWith('#'));
+// Niente parser YAML nel pacchetto: la ricerca è testuale. Una riga commentata non soddisfa nessun
+// controllo, altrimenti basta commentare un passo per avere un progetto «a posto» che non lo lancia.
+export const isLive = (line) => !line.trimStart().startsWith('#');
+const liveLines = (source) => source.split(/\r?\n/).filter(isLive);
 export const mentions = (source, needle) => source !== undefined && liveLines(source).some((line) => line.includes(needle));
 const ACTIONS = [
     { workflow: '.github/workflows/ci.yml', action: 'ci' },
@@ -50,21 +50,3 @@ export function workflowGaps({ read }, version) {
         return message === undefined ? [] : [{ path: workflow, message }];
     });
 }
-const DEPENDABOT = '.github/dependabot.yml';
-// Senza il gruppo, Dependabot apre due PR — una per il pacchetto npm, una per le action — e il
-// controllo di coerenza qui sopra le boccia entrambe, perché nessuna delle due allinea l'altra.
-const GROUPED = [
-    { needle: 'multi-ecosystem-groups', reason: 'il pacchetto e le sue action si alzano in una PR sola' },
-    { needle: '@elia97/officina', reason: 'il gruppo deve prendere il pacchetto da npm' },
-    { needle: 'Elia97/officina/*', reason: 'il gruppo deve prendere le action da github-actions' },
-];
-export function dependabotGaps({ read }) {
-    const source = read(DEPENDABOT);
-    if (source === undefined) {
-        return [{ path: DEPENDABOT, message: 'manca: senza, il pacchetto e le sue action si alzano separati' }];
-    }
-    return GROUPED.filter(({ needle }) => !mentions(source, needle)).map(({ needle, reason }) => ({
-        path: DEPENDABOT,
-        message: `non nomina \`${needle}\`: ${reason}`,
-    }));
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elia97/officina",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Gli strumenti dei progetti nati dai template di Elia: gate di qualità, generatori e verifiche di build e di produzione.",
   "type": "module",
   "license": "MIT",
@@ -55,7 +55,7 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.5.10",
-    "@types/node": "^24.13.5",
+    "@types/node": "^26.5.1",
     "@vitest/coverage-v8": "^4.1.11",
     "fallow": "^3.26.0",
     "typescript": "^7.0.2",
@@ -63,7 +63,8 @@
   },
   "dependencies": {
     "plop": "^4.0.5",
-    "ts-morph": "^28.0.0"
+    "ts-morph": "^28.0.0",
+    "yaml": "^2.9.1"
   },
   "peerDependencies": {
     "@biomejs/biome": ">=2.5.10 <3.0.0",