@aurorajs.dev/catalyst-cli 1.1.3 → 2.0.0

package/dist/templates/monorepo/scripts/backlog/worker-edit.ts

@@ -29,7 +29,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { resolveTestCommand } from './guards.js';
 import { parseFilesToTouch, parseTestCommand } from './task-view.js';
-import { EXECUTION_PATH, LANE, TIER, type ExecutionPath, type Lane, type Tier } from './types.js';
+import { EXECUTION_PATH, LANE, MODE, TIER, type ExecutionPath, type Lane, type Tier } from './types.js';
 
 /**
  * The write flags a worker legitimately needs on its own task: tick a criterion it has evidence
@@ -163,10 +163,10 @@ function resolveSubtaskDesc(
 }
 
 /**
- * Every `tier:`/`lane:`/`path:`/`bc:` label a subtask must carry, read against the SAME const maps
- * `types.ts` exports for the board taxonomy — a typo here must fail the same way a typo in an
- * interactive `backlog task create -l ...` invocation would eventually fail guard 1, not silently
- * create a task guard 1 then blocks.
+ * Every `tier:`/`lane:`/`path:`/`mode:`/`bc:` label a subtask must carry, read against the SAME
+ * const maps `types.ts` exports for the board taxonomy — a typo here must fail the same way a typo
+ * in an interactive `backlog task create -l ...` invocation would eventually fail guard 1, not
+ * silently create a task guard 1 then blocks.
  */
 function validateSubtaskLabels(labelsRaw: string): { kind: 'ok'; lane: Lane } | Refused {
   const entries = labelsRaw
@@ -178,6 +178,7 @@ function validateSubtaskLabels(labelsRaw: string): { kind: 'ok'; lane: Lane } |
   const tierEntries = findPrefix('tier:');
   const laneEntries = findPrefix('lane:');
   const pathEntries = findPrefix('path:');
+  const modeEntries = findPrefix('mode:');
   const bcEntries = findPrefix('bc:');
   if (tierEntries.length !== 1) {
     return refuseSubtask(`--labels debe declarar exactamente un "tier:" (encontrados: ${tierEntries.length}).`);
@@ -188,6 +189,13 @@ function validateSubtaskLabels(labelsRaw: string): { kind: 'ok'; lane: Lane } |
   if (pathEntries.length !== 1) {
     return refuseSubtask(`--labels debe declarar exactamente un "path:" (encontrados: ${pathEntries.length}).`);
   }
+  // `mode:` joins the OTHER three's presence check here on purpose — it is the fifth mandatory
+  // triage label (design.md decision 3), not an optional extra, so a subtask missing it is exactly
+  // as untriaged as one missing `tier:`/`lane:`/`path:` and must be refused the same way, before it
+  // ever reaches the board.
+  if (modeEntries.length !== 1) {
+    return refuseSubtask(`--labels debe declarar exactamente un "mode:" (encontrados: ${modeEntries.length}).`);
+  }
   if (bcEntries.length !== 1) {
     return refuseSubtask(`--labels debe declarar exactamente un "bc:" (encontrados: ${bcEntries.length}).`);
   }
@@ -195,9 +203,11 @@ function validateSubtaskLabels(labelsRaw: string): { kind: 'ok'; lane: Lane } |
   const tierValue = tierEntries[0].slice('tier:'.length);
   const laneValue = laneEntries[0].slice('lane:'.length);
   const pathValue = pathEntries[0].slice('path:'.length);
+  const modeValue = modeEntries[0].slice('mode:'.length);
   const legalTiers: readonly string[] = Object.values(TIER);
   const legalLanes: readonly string[] = Object.values(LANE);
   const legalPaths: readonly string[] = Object.values(EXECUTION_PATH);
+  const legalModes: readonly string[] = Object.values(MODE);
 
   if (!legalTiers.includes(tierValue)) {
     return refuseSubtask(`valor de "tier:" no permitido: "${tierValue}". Válidos: ${legalTiers.join(', ')}.`);
@@ -208,6 +218,9 @@ function validateSubtaskLabels(labelsRaw: string): { kind: 'ok'; lane: Lane } |
   if (!legalPaths.includes(pathValue)) {
     return refuseSubtask(`valor de "path:" no permitido: "${pathValue}". Válidos: ${legalPaths.join(', ')}.`);
   }
+  if (!legalModes.includes(modeValue)) {
+    return refuseSubtask(`valor de "mode:" no permitido: "${modeValue}". Válidos: ${legalModes.join(', ')}.`);
+  }
   // Mirrors the label taxonomy's own rule (SKILL.md §2): tier:complex never dispatches to
   // lane:local, regardless of where the subtask is later queued.
   if ((tierValue as Tier) === TIER.COMPLEX && (laneValue as Lane) !== LANE.FRONTIER) {

package/dist/templates/monorepo/scripts/harness-rules/lint-barrels.test.ts

@@ -104,7 +104,7 @@ describe('unitOf()', () => {
     assert.equal(unitOf(file, REPO), undefined);
   });
 
-  // HR-BARRELS-003 (task 5.5): cada superficie declarada del @aurora frontend
+  // HR-BARRELS-004 (task 5.5): cada superficie declarada del @aurora frontend
   // (grupo o módulo, tabla D1 de reduce-frontend-eager-payload) cuenta como unidad gobernada.
   it('frontend @aurora/components/** (superficie de grupo) → "@aurora/components"', () => {
     const file = `${REPO}/frontend/src/@aurora/components/data-table/cells/boolean-cell.component.ts`;
@@ -148,7 +148,7 @@ describe('suggestBarrel()', () => {
     assert.equal(suggestBarrel(file, REPO), 'o-auth/client');
   });
 
-  // HR-BARRELS-003 (task 5.8): frontend @aurora surfaces must suggest their declared alias too,
+  // HR-BARRELS-004 (task 5.8): frontend @aurora surfaces must suggest their declared alias too,
   // mirroring unitOf() (task 5.5) so the message names the barrel a developer should import from.
   it('frontend @aurora/components/** (superficie de grupo) → "@aurora/components"', () => {
     const file = `${REPO}/frontend/src/@aurora/components/data-table/cells/boolean-cell.component.ts`;
@@ -227,13 +227,63 @@ describe('resolveSpecifier()', () => {
     );
     assert.equal(resolved, `${BACKEND}/@aurora/modules/authentication/domain/ports/index.ts`);
   });
+
+  // GROUP 10 (10.1/10.2) — explicit ESM specifiers must resolve like their extensionless form.
+  it('resuelve un specifier de FICHERO explícito (.js) a su .ts', () => {
+    const importer = `${BACKEND}/@app/o-auth/flows/application/create.handler.ts`;
+    const resolved = resolveSpecifier(
+      '@app/o-auth/access-token/application/create/o-auth-create-access-token.service.js',
+      importer,
+      backendPaths,
+      existsIn(
+        `${BACKEND}/@app/o-auth/access-token/application/create/o-auth-create-access-token.service.ts`,
+      ),
+    );
+    assert.equal(
+      resolved,
+      `${BACKEND}/@app/o-auth/access-token/application/create/o-auth-create-access-token.service.ts`,
+    );
+  });
+
+  it('resuelve un specifier de BARREL explícito (/index.js) a su index.ts', () => {
+    const importer = `${BACKEND}/@app/o-auth/flows/application/create.handler.ts`;
+    const resolved = resolveSpecifier(
+      '@app/iam/tag/index.js',
+      importer,
+      backendPaths,
+      existsIn(`${BACKEND}/@app/iam/tag/index.ts`),
+    );
+    assert.equal(resolved, `${BACKEND}/@app/iam/tag/index.ts`);
+  });
+
+  it('resuelve un specifier relativo explícito (.js) a su .ts', () => {
+    const importer = `${FRONTEND}/o-auth/client/ui/client-list.component.ts`;
+    const resolved = resolveSpecifier(
+      '../../application/data-access/application.list-config.js',
+      importer,
+      {},
+      existsIn(`${FRONTEND}/o-auth/application/data-access/application.list-config.ts`),
+    );
+    assert.equal(resolved, `${FRONTEND}/o-auth/application/data-access/application.list-config.ts`);
+  });
+
+  it('un specifier explícito (.js) que no existe en disco sigue sin resolver (fail-open intacto)', () => {
+    const importer = `${BACKEND}/@app/o-auth/flows/application/create.handler.ts`;
+    const resolved = resolveSpecifier(
+      '@app/o-auth/nonexistent.js',
+      importer,
+      backendPaths,
+      () => false,
+    );
+    assert.equal(resolved, undefined);
+  });
 });
 
 // ---------------------------------------------------------------------------
 // 5.5 — resolveSpecifier() con alias EXACTOS del frontend @aurora (D1, sin '/*')
 // ---------------------------------------------------------------------------
 
-describe('resolveSpecifier() — alias exacto frontend @aurora (HR-BARRELS-003)', () => {
+describe('resolveSpecifier() — alias exacto frontend @aurora (HR-BARRELS-004)', () => {
   // frontend/tsconfig.json declara estos alias como entradas EXACTAS (sin comodín '/*'),
   // a diferencia de los alias de backend: "@aurora/components": ["./src/@aurora/components/index.ts"].
   const frontendAuroraPaths: Record<string, string[]> = {
@@ -315,6 +365,26 @@ describe('extractSpecifiers()', () => {
     assert.equal(results[0].line, 1);
   });
 
+  // GROUP 10 (10.5) — vi.mock() must be extracted identically to jest.mock().
+  it('extrae vi.mock() con literal', () => {
+    const source = `vi.mock('@app/o-auth/flows/application/session/o-auth-hub-session.service.js');\n`;
+    const results = extractSpecifiers(source);
+    assert.equal(results.length, 1);
+    assert.equal(
+      results[0].specifier,
+      '@app/o-auth/flows/application/session/o-auth-hub-session.service.js',
+    );
+    assert.equal(results[0].line, 1);
+    assert.equal(results[0].kind, 'static');
+  });
+
+  it('extrae vi.mock() de un barrel de módulo', () => {
+    const source = `vi.mock('@app/hub/app/domain/index.js', () => ({ HubAppFieldSchema: [] }));\n`;
+    const results = extractSpecifiers(source);
+    assert.equal(results.length, 1);
+    assert.equal(results[0].specifier, '@app/hub/app/domain/index.js');
+  });
+
   it('ignora import() dinámico con variable (no literal)', () => {
     const source = `const m = import(somePath);\n`;
     const results = extractSpecifiers(source);
@@ -346,6 +416,32 @@ describe('extractSpecifiers()', () => {
     assert.equal(results.length, 1);
     assert.equal(results[0].specifier, '@app/o-auth/shared');
   });
+
+  // T-45: cada specifier lleva su 'kind' de origen — es lo que permite a classifyImport()
+  // eximir el import() dinámico sin tocar el resto del pipeline (extractSpecifiers no toca disco).
+  it('etiqueta un import ... from estático con kind "static"', () => {
+    const source = `import { Foo } from '@app/o-auth/shared';\n`;
+    const results = extractSpecifiers(source);
+    assert.equal(results[0].kind, 'static');
+  });
+
+  it('etiqueta un export ... from estático con kind "static"', () => {
+    const source = `export { Bar } from '@bridges/iam/permission';\n`;
+    const results = extractSpecifiers(source);
+    assert.equal(results[0].kind, 'static');
+  });
+
+  it('etiqueta un jest.mock() con kind "static"', () => {
+    const source = `jest.mock('@app/iam/user/application/create.service');\n`;
+    const results = extractSpecifiers(source);
+    assert.equal(results[0].kind, 'static');
+  });
+
+  it('etiqueta un import() dinámico con kind "dynamic"', () => {
+    const source = `const m = import('./queue/features/queue-list.component');\n`;
+    const results = extractSpecifiers(source);
+    assert.equal(results[0].kind, 'dynamic');
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -545,10 +641,75 @@ describe('classifyImport() — HR-BARRELS-001', () => {
 });
 
 // ---------------------------------------------------------------------------
-// 5.5 — classifyImport() — HR-BARRELS-003 (frontend @aurora sub-barrel aliases)
+// GROUP 10 (10.1) — classifyImport() gives the explicit ESM form the SAME verdict
+// as its extensionless form (barrels-lint-guard spec.md scenarios).
 // ---------------------------------------------------------------------------
 
-describe('classifyImport() — HR-BARRELS-003 (frontend @aurora)', () => {
+describe('classifyImport() — explicit ESM specifiers (GROUP 10)', () => {
+  const backendPaths: Record<string, string[]> = {
+    '@api/*': [`${BACKEND}/@api/*`],
+    '@app/*': [`${BACKEND}/@app/*`],
+    '@aurora/*': [`${BACKEND}/@aurora/*`],
+    '@bridges/*': [`${BACKEND}/@bridges/*`],
+    '@config/*': [`${BACKEND}/@config/*`],
+  };
+
+  it('cross-unit deep-path escrito con .js explícito → violation (HR-BARRELS-004)', () => {
+    const importer = `${BACKEND}/@app/o-auth/flows/application/create.handler.ts`;
+    const result = classifyImport(
+      importer,
+      '@app/o-auth/access-token/application/create/o-auth-create-access-token.service.js',
+      backendPaths,
+      existsIn(
+        `${BACKEND}/@app/o-auth/access-token/application/create/o-auth-create-access-token.service.ts`,
+      ),
+      REPO,
+    );
+    assert.equal(result, 'violation');
+  });
+
+  it('barrel de módulo escrito como /index.js → OK', () => {
+    const importer = `${BACKEND}/@app/o-auth/flows/application/create.handler.ts`;
+    const result = classifyImport(
+      importer,
+      '@app/iam/tag/index.js',
+      backendPaths,
+      existsIn(`${BACKEND}/@app/iam/tag/index.ts`),
+      REPO,
+    );
+    assert.equal(result, 'ok');
+  });
+
+  it('sub-barrel escrito como /index.js → OK', () => {
+    const importer = `${BACKEND}/@app/o-auth/flows/get-jwks.handler.ts`;
+    const result = classifyImport(
+      importer,
+      '@aurora/modules/authentication/domain/ports/index.js',
+      backendPaths,
+      existsIn(`${BACKEND}/@aurora/modules/authentication/domain/ports/index.ts`),
+      REPO,
+    );
+    assert.equal(result, 'ok');
+  });
+
+  it('relativo cross-unit escrito con .js explícito → violation', () => {
+    const importer = `${FRONTEND}/o-auth/client/ui/client-list.component.ts`;
+    const result = classifyImport(
+      importer,
+      '../../application/data-access/application.list-config.js',
+      {},
+      existsIn(`${FRONTEND}/o-auth/application/data-access/application.list-config.ts`),
+      REPO,
+    );
+    assert.equal(result, 'violation');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 5.5 — classifyImport() — HR-BARRELS-004 (frontend @aurora sub-barrel aliases)
+// ---------------------------------------------------------------------------
+
+describe('classifyImport() — HR-BARRELS-004 (frontend @aurora)', () => {
   // frontend/tsconfig.json declara estos alias como entradas EXACTAS (D1 del design de
   // reduce-frontend-eager-payload), nunca un comodín '@aurora/*'.
   const frontendAuroraPaths: Record<string, string[]> = {
@@ -559,7 +720,7 @@ describe('classifyImport() — HR-BARRELS-003 (frontend @aurora)', () => {
 
   // Caso rojo (task 5.5): la tabla de alias no puede impedir que un specifier RELATIVO
   // escape a un fichero de implementación del @aurora frontend — el linter debe seguir
-  // cazándolo, ahora atribuido a HR-BARRELS-003 en vez de a la derogada HR-BARRELS-001.
+  // cazándolo, ahora atribuido a HR-BARRELS-004 en vez de a la derogada HR-BARRELS-001.
   it('relativo que escapa a un fichero de implementación de @aurora → violation', () => {
     const importer = `${FRONTEND}/iam/widgets/iam.widgets.ts`;
     const result = classifyImport(
@@ -611,6 +772,29 @@ describe('classifyImport() — HR-BARRELS-003 (frontend @aurora)', () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// T-45 — classifyImport() — exención de FORMA para import() dinámico (HR-BARRELS-004)
+// ---------------------------------------------------------------------------
+
+describe('classifyImport() — exención de import() dinámico (HR-BARRELS-004, T-45)', () => {
+  // Mismo shape que el caso real medido en queue-manager.routes.ts: el fichero de rutas vive
+  // en la raíz del BC (sin unidad propia) y su loadComponent apunta a un fichero de
+  // implementación de otro módulo — sin la exención, esto es 'violation' (caso 3 de la matriz).
+  const importer = `${FRONTEND}/queue-manager/queue-manager.routes.ts`;
+  const deepPathSpecifier = './queue/features/queue-list.component';
+  const existsDeepFile = existsIn(`${FRONTEND}/queue-manager/queue/features/queue-list.component.ts`);
+
+  it('deep-path dinámico sin exención (isDynamicImport omitido) → violation', () => {
+    const result = classifyImport(importer, deepPathSpecifier, {}, existsDeepFile, REPO);
+    assert.equal(result, 'violation');
+  });
+
+  it('el MISMO deep-path, marcado isDynamicImport=true → ok (chunk boundary deliberado)', () => {
+    const result = classifyImport(importer, deepPathSpecifier, {}, existsDeepFile, REPO, true);
+    assert.equal(result, 'ok');
+  });
+});
+
 // ---------------------------------------------------------------------------
 // 1.5 — checkBarrels002() — HR-BARRELS-002 chequeos estructurales
 // ---------------------------------------------------------------------------
@@ -733,6 +917,48 @@ describe('checkBarrels002()', () => {
     const violations = checkBarrels002.checkBcBarrelInBridges(filePath, REPO, () => true);
     assert.equal(violations.length, 0);
   });
+
+  // GROUP 10 (10.3) — the same 002-A/002-B anchors, written in explicit ESM form.
+  it('002-A explícito: "export * from ./adapters/index.js" → violation', () => {
+    const barrelPath = `${BACKEND}/@bridges/iam/permission/index.ts`;
+    const content = `export * from './ports/index.js';\nexport * from './adapters/index.js';\n`;
+    const violations = checkBarrels002.checkAdapterLeakInBarrel(barrelPath, content, REPO);
+    assert.equal(violations.length, 1);
+  });
+
+  it('002-A explícito: re-export de un fichero *.adapter.js → violation', () => {
+    const barrelPath = `${BACKEND}/@bridges/o-auth/application/index.ts`;
+    const content = `export * from './ports/index.js';\nexport { OAuthApplicationAdapter } from './adapters/o-auth-application.adapter.js';\n`;
+    const violations = checkBarrels002.checkAdapterLeakInBarrel(barrelPath, content, REPO);
+    assert.equal(violations.length, 1);
+  });
+
+  it('002-A explícito: helper puro (sin sufijo .adapter) sigue exento en forma explícita', () => {
+    const barrelPath = `${BACKEND}/@bridges/o-auth/application/index.ts`;
+    const content = `export * from './adapters/validate-redirect-uri.js';\n`;
+    const violations = checkBarrels002.checkAdapterLeakInBarrel(barrelPath, content, REPO);
+    assert.equal(violations.length, 0);
+  });
+
+  it('002-B explícito: import de @bridges/<bc>/<module>/adapters/index.js desde handler → violation', () => {
+    const importer = `${BACKEND}/@app/iam/user/application/create-user.handler.ts`;
+    const violations = checkBarrels002.checkAdaptersImportOutsideCompositionRoots(
+      importer,
+      '@bridges/iam/permission/adapters/index.js',
+      REPO,
+    );
+    assert.equal(violations.length, 1);
+  });
+
+  it('002-B explícito: import de @bridges/.../adapters/index.js desde un composition root → OK', () => {
+    const importer = `${BACKEND}/@bridges/bridges.module.ts`;
+    const violations = checkBarrels002.checkAdaptersImportOutsideCompositionRoots(
+      importer,
+      '@bridges/iam/permission/adapters/index.js',
+      REPO,
+    );
+    assert.equal(violations.length, 0);
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -791,6 +1017,33 @@ describe('lintFile()', () => {
     const findings002c = findings.filter((f) => f.kind === '002');
     assert.equal(findings002c.length, 1);
   });
+
+  // T-45: mismo fichero que el caso real (queue-manager.routes.ts) con AMBAS formas de import
+  // hacia sendos deep-paths cross-unit — el import() dinámico de la ruta lazy queda exento por
+  // FORMA, el import ... from estático (p.ej. un resolver) sigue siendo deep-path prohibido.
+  // Cubre las dos direcciones exigidas por el criterio de aceptación 1 en un único fichero.
+  it('import() dinámico exento, import ... from estático en el MISMO fichero sigue violando', () => {
+    const file = `${FRONTEND}/queue-manager/queue-manager.routes.ts`;
+    const content = [
+      `import { someResolver } from './queue/features/queue-list.resolver';`,
+      `export const queueManagerRoutes = [`,
+      `  { path: '', loadComponent: () => import('./queue/features/queue-list.component') },`,
+      `];`,
+    ].join('\n');
+    const findings = lintFile(
+      file,
+      content,
+      {},
+      REPO,
+      existsIn(
+        `${FRONTEND}/queue-manager/queue/features/queue-list.resolver.ts`,
+        `${FRONTEND}/queue-manager/queue/features/queue-list.component.ts`,
+      ),
+    );
+    const findings001 = findings.filter((f) => f.kind === '001') as Array<{ specifier: string }>;
+    assert.equal(findings001.length, 1);
+    assert.equal(findings001[0].specifier, './queue/features/queue-list.resolver');
+  });
 });
 
 describe('isGeneratedFile()', () => {