@bleedingdev/modern-js-create 3.4.0-ultramodern.9 → 3.5.0-ultramodern.1

package/template-workspace/scripts/bootstrap-agent-skills.mjs

@@ -2,19 +2,22 @@ import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 const root = process.cwd();
-const lockPath = path.join(root, '.agents/skills-lock.json');
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const templateWorkspaceDir = path.resolve(scriptDir, '..');
+const vendoredSkillsDir = path.join(templateWorkspaceDir, '.codex/skills');
+const lockPath = path.join(root, '.codex/skills-lock.json');
 const checkOnly = process.argv.includes('--check');
-const force = process.argv.includes('--force');
 const postinstall = process.argv.includes('--postinstall');
 const truthy = value => /^(1|true|yes|on)$/i.test(String(value ?? ''));
 const falsy = value => /^(0|false|no|off)$/i.test(String(value ?? ''));
 const skipRequested =
-  truthy(process.env.ULTRAMODERN_SKIP_AGENT_SKILLS) ||
-  falsy(process.env.ULTRAMODERN_AGENT_SKILLS);
+  truthy(process.env.ULTRAMODERN_SKIP_CODEX_SKILLS) ||
+  falsy(process.env.ULTRAMODERN_CODEX_SKILLS);
 const cloneTimeoutMs = Number.parseInt(
-  process.env.ULTRAMODERN_AGENT_SKILLS_CLONE_TIMEOUT_MS ?? '60000',
+  process.env.ULTRAMODERN_CODEX_SKILLS_CLONE_TIMEOUT_MS ?? '60000',
   10,
 );
 
@@ -60,7 +63,7 @@ const requireGit = () => {
   }
 
   throw new Error(
-    'Git is required to install agent skills. Install git yourself (for example "brew install git" or "sudo apt-get install git") and run pnpm skills:install again. This script never installs system packages on your behalf.',
+    'Git is required to install clone-backed Codex skills. Install git yourself (for example "brew install git" or "sudo apt-get install git") and run pnpm skills:install again. This script never installs system packages on your behalf.',
   );
 };
 
@@ -172,31 +175,42 @@ const resolveSkillDir = (sourceRoot, skillName) => {
 };
 
 if (!fs.existsSync(lockPath)) {
-  console.error('Missing .agents/skills-lock.json');
+  console.error('Missing .codex/skills-lock.json');
   process.exit(1);
 }
 
 const lock = readJson(lockPath);
-const installDir = path.join(root, lock.installDir ?? '.agents/skills');
+const installDir = path.join(root, lock.installDir ?? '.codex/skills');
 const sources = lock.sources ?? [];
-const requiredCloneSources = sources.filter(
-  source => source.install === 'clone',
-);
+const vendoredSources = sources.filter(source => source.install === 'vendored');
+const cloneSources = sources.filter(source => source.install === 'clone');
 const optionalCloneSources = sources.filter(
   source => source.install === 'clone-if-authorized',
 );
-const cloneSourceSkillNames = new Set(
-  [...requiredCloneSources, ...optionalCloneSources].flatMap(source =>
-    (source.baseline ?? []).map(skill => skill.name),
+const explicitSourceSkillNames = new Set(
+  [...vendoredSources, ...cloneSources, ...optionalCloneSources].flatMap(
+    source => (source.baseline ?? []).map(skill => skill.name),
   ),
 );
-const vendoredRequiredSkills = (lock.baseline ?? []).filter(
-  skill => !cloneSourceSkillNames.has(skill.name),
-);
-const cloneOptIn = truthy(process.env.ULTRAMODERN_AGENT_SKILLS);
+const skillsForSource = source =>
+  source.baseline ??
+  (source.install === 'vendored'
+    ? (lock.baseline ?? []).filter(
+        skill => !explicitSourceSkillNames.has(skill.name),
+      )
+    : []);
+const lockedSkillNames = (lock.baseline ?? []).map(skill => skill.name);
+const installedSkillNames = () =>
+  lockedSkillNames.filter(skillName =>
+    fs.existsSync(path.join(installDir, skillName, 'SKILL.md')),
+  );
+const missingSkillNames = () =>
+  lockedSkillNames.filter(
+    skillName => !fs.existsSync(path.join(installDir, skillName, 'SKILL.md')),
+  );
 
 if (skipRequested) {
-  const reason = 'agent skills bootstrap skipped by environment';
+  const reason = 'Codex skills bootstrap skipped by environment';
   if (checkOnly) {
     console.log(reason);
     process.exit(0);
@@ -207,80 +221,76 @@ if (skipRequested) {
 }
 
 if (checkOnly) {
-  const missingVendored = vendoredRequiredSkills
-    .map(skill => skill.name)
-    .filter(
-      skillName => !fs.existsSync(path.join(installDir, skillName, 'SKILL.md')),
-    );
-  const missingCloneInstalled = [
-    ...requiredCloneSources,
-    ...optionalCloneSources,
-  ].flatMap(source =>
-    (source.baseline ?? [])
-      .map(skill => skill.name)
-      .filter(
-        skillName =>
-          !fs.existsSync(path.join(installDir, skillName, 'SKILL.md')),
-      ),
-  );
-
-  if (missingVendored.length > 0) {
-    console.error(
-      `Required agent skills not installed: ${missingVendored.join(', ')}. Run pnpm skills:install.`,
-    );
-    process.exit(1);
-  }
-
-  if (missingCloneInstalled.length > 0) {
+  const missing = missingSkillNames();
+  const installed = installedSkillNames();
+  if (missing.length > 0) {
     console.log(
-      `Advisory: clone-installed agent skills are not present: ${missingCloneInstalled.join(', ')}. This is expected in CI, nested generated workspaces, and postinstall-only installs; run pnpm skills:install when you need those skills.`,
+      `Advisory: pinned Codex skills are not installed: ${missing.join(', ')}. This is expected in offline postinstall runs and fresh check-only CI; run pnpm skills:install when you need local skill bodies.`,
     );
   } else {
-    console.log('All pinned agent skills are installed.');
+    console.log('All pinned Codex skills are installed.');
+  }
+  if (installed.length > 0) {
+    console.log(`Installed Codex skills: ${installed.join(', ')}.`);
   }
   process.exit(0);
 }
 
-if (postinstall && !cloneOptIn) {
-  console.log(
-    'Skipping agent skill repository clones during postinstall. Run pnpm skills:install (or set ULTRAMODERN_AGENT_SKILLS=1 before installing) to fetch them.',
-  );
-  installLefthook();
-  process.exit(0);
+fs.mkdirSync(installDir, { recursive: true });
+
+const installSkillFromDir = (sourceSkillDir, skillName) => {
+  const targetSkillDir = path.join(installDir, skillName);
+  if (path.resolve(sourceSkillDir) === path.resolve(targetSkillDir)) {
+    console.log(`Pinned Codex skill ${skillName} is already present`);
+    return;
+  }
+  if (fs.existsSync(targetSkillDir)) {
+    removeTree(targetSkillDir);
+  }
+  fs.mkdirSync(path.dirname(targetSkillDir), { recursive: true });
+  fs.cpSync(sourceSkillDir, targetSkillDir, { recursive: true });
+  console.log(`Installed Codex skill ${skillName}`);
+};
+
+for (const source of vendoredSources) {
+  for (const skill of skillsForSource(source)) {
+    const sourceSkillDir = resolveSkillDir(vendoredSkillsDir, skill.name);
+    if (!sourceSkillDir) {
+      throw new Error(
+        `Vendored Codex skill ${skill.name} not found in ${vendoredSkillsDir}`,
+      );
+    }
+    installSkillFromDir(sourceSkillDir, skill.name);
+  }
 }
 
-fs.mkdirSync(installDir, { recursive: true });
-requireGit();
+const cloneInstallSources = postinstall
+  ? cloneSources
+  : [...cloneSources, ...optionalCloneSources];
 
-for (const source of [...requiredCloneSources, ...optionalCloneSources]) {
+for (const source of cloneInstallSources) {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ultramodern-skills-'));
   try {
     try {
+      requireGit();
       cloneSource(source, tempDir);
     } catch (error) {
       if (source.install === 'clone-if-authorized' || postinstall) {
-        console.warn(`Skipping ${source.repository}; ${error.message}`);
+        console.warn(
+          `Advisory: unable to install Codex skills from ${source.repository}; ${error.message}. Offline postinstall may continue. Run pnpm skills:install later when network access is available.`,
+        );
         continue;
       }
       throw error;
     }
-    for (const skill of source.baseline ?? []) {
+    for (const skill of skillsForSource(source)) {
       const sourceSkillDir = resolveSkillDir(tempDir, skill.name);
       if (!sourceSkillDir) {
         throw new Error(
           `Skill ${skill.name} not found in ${source.repository}`,
         );
       }
-      const targetSkillDir = path.join(installDir, skill.name);
-      if (fs.existsSync(targetSkillDir)) {
-        if (!force) {
-          console.log(`Skipping existing ${skill.name}`);
-          continue;
-        }
-        removeTree(targetSkillDir);
-      }
-      fs.cpSync(sourceSkillDir, targetSkillDir, { recursive: true });
-      console.log(`Installed ${skill.name}`);
+      installSkillFromDir(sourceSkillDir, skill.name);
     }
   } finally {
     removeTree(tempDir);

package/templates/workspace-scripts/assert-mf-types.mjs.handlebars

@@ -2,19 +2,62 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 const root = process.cwd();
-const generatedContractPath = path.join(
-  root,
-  '.modernjs/ultramodern-generated-contract.json',
-);
-const generatedContract = fs.existsSync(generatedContractPath)
-  ? JSON.parse(fs.readFileSync(generatedContractPath, 'utf-8'))
-  : undefined;
+const compactConfigPath = path.join(root, '.modernjs/ultramodern.json');
 const defaultAppDirs = {{defaultAppDirsJson}};
 
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+}
+
+function normalizeRelativePath(value) {
+  return String(value ?? '').replace(/\\/gu, '/').replace(/^\.\/+/u, '');
+}
+
+function readGeneratedContractView() {
+  if (fs.existsSync(compactConfigPath)) {
+    const compactConfig = readJson(compactConfigPath);
+    return {
+      sourcePath: compactConfigPath,
+      apps: Array.isArray(compactConfig.topology?.apps)
+        ? compactConfig.topology.apps.map(app => {
+            const moduleFederation =
+              app.moduleFederation && typeof app.moduleFederation === 'object'
+                ? app.moduleFederation
+                : {};
+            return {
+              id: String(app.id),
+              path:
+                typeof app.path === 'string'
+                  ? normalizeRelativePath(app.path)
+                  : '.',
+              moduleFederation: {
+                exposes: Array.isArray(moduleFederation.exposes)
+                  ? moduleFederation.exposes.filter(
+                      expose => typeof expose === 'string',
+                    )
+                  : [],
+                dts: {
+                  compilerInstance:
+                    moduleFederation.dts?.compilerInstance ?? 'tsgo',
+                  tsConfigPath:
+                    moduleFederation.dts?.tsConfigPath ??
+                    './tsconfig.mf-types.json',
+                },
+              },
+            };
+          })
+        : [],
+    };
+  }
+  throw new Error('Missing UltraModern config. Expected .modernjs/ultramodern.json.');
+}
+
+const generatedContract = readGeneratedContractView();
+
 const args = process.argv.slice(2);
 if (args.includes('--help') || args.includes('-h')) {
   process.stdout.write(`Usage:
-  node scripts/assert-mf-types.mjs [app-dir...]
+  node scripts/assert-mf-types.mts [app-dir...]
 
 Checks that every Module Federation remote with exposed modules emitted a non-empty dist/@mf-types.zip archive and uses the workspace TypeScript compiler.
 `);

package/templates/workspace-scripts/check-ultramodern-api-boundaries.mts

@@ -0,0 +1,366 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+
+const workspaceRoot = process.env.ULTRAMODERN_WORKSPACE_ROOT ?? process.cwd();
+const failures = [];
+
+const ignoredDirectories = new Set([
+  '.git',
+  '.modern',
+  '.output',
+  'coverage',
+  'dist',
+  'node_modules',
+  'repos',
+]);
+
+function normalize(filePath) {
+  return filePath.split(path.sep).join('/');
+}
+
+function relative(filePath) {
+  return normalize(path.relative(workspaceRoot, filePath));
+}
+
+function exists(relativePath) {
+  return fs.existsSync(path.join(workspaceRoot, relativePath));
+}
+
+function readText(relativePath) {
+  return fs.readFileSync(path.join(workspaceRoot, relativePath), 'utf8');
+}
+
+function fail(message) {
+  failures.push(message);
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    fail(message);
+  }
+}
+
+function listFiles(startDirectory) {
+  const absoluteStart = path.join(workspaceRoot, startDirectory);
+  if (!fs.existsSync(absoluteStart)) {
+    return [];
+  }
+
+  const files = [];
+  const visit = directory => {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      if (ignoredDirectories.has(entry.name)) {
+        continue;
+      }
+
+      const absoluteEntry = path.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        visit(absoluteEntry);
+        continue;
+      }
+
+      if (entry.isFile()) {
+        files.push(relative(absoluteEntry));
+      }
+    }
+  };
+
+  visit(absoluteStart);
+  return files;
+}
+
+function listDirectories(startDirectory) {
+  const absoluteStart = path.join(workspaceRoot, startDirectory);
+  if (!fs.existsSync(absoluteStart)) {
+    return [];
+  }
+
+  return fs
+    .readdirSync(absoluteStart, { withFileTypes: true })
+    .filter(entry => entry.isDirectory() && !ignoredDirectories.has(entry.name))
+    .map(entry => path.posix.join(startDirectory, entry.name));
+}
+
+function assertNoPath(relativePath, message) {
+  if (exists(relativePath)) {
+    fail(message);
+  }
+}
+
+function assertContains(relativePath, content, pattern, message) {
+  assert(pattern.test(content), `${relativePath}: ${message}`);
+}
+
+function assertNotContains(relativePath, content, pattern, message) {
+  assert(!pattern.test(content), `${relativePath}: ${message}`);
+}
+
+for (const forbiddenPath of [
+  ...listDirectories('apps').flatMap(appPath => [
+    `${appPath}/api/effect`,
+    `${appPath}/api/lambda`,
+    `${appPath}/shared/effect`,
+    `${appPath}/src/effect`,
+  ]),
+  ...listDirectories('verticals').flatMap(verticalPath => [
+    `${verticalPath}/api/effect`,
+    `${verticalPath}/api/lambda`,
+    `${verticalPath}/shared/effect`,
+    `${verticalPath}/src/effect`,
+  ]),
+]) {
+  assertNoPath(
+    forbiddenPath,
+    `${forbiddenPath} is forbidden in UltraModern strictEffectApproach workspaces; use api/index.ts, shared/api.ts and src/api/* instead.`,
+  );
+}
+
+const generatedFiles = [
+  ...listFiles('apps'),
+  ...listFiles('verticals'),
+  ...listFiles('packages'),
+];
+const textFiles = generatedFiles.filter(file =>
+  /\.(?:[cm]?[jt]sx?|json|md|mjs|mts|cts)$/u.test(file),
+);
+
+for (const file of textFiles) {
+  const content = readText(file);
+
+  if (/\/api\//u.test(file)) {
+    assertNotContains(
+      file,
+      content,
+      /\bnew\s+Response\s*\(|\bResponse\.json\s*\(/u,
+      'API modules must not hand-build Response objects; model endpoints through Effect HttpApi and schemas.',
+    );
+    assertNotContains(
+      file,
+      content,
+      /\b(?:request|req)\.(?:json|text|formData|arrayBuffer)\s*\(/u,
+      'API modules must not manually parse request bodies; use HttpApiEndpoint payload/query/params schemas.',
+    );
+    assertNotContains(
+      file,
+      content,
+      /\bexport\s+const\s+handler\b|\bexport\s+default\s+async\b/u,
+      'API modules must not export raw request handlers; export defineEffectBff(...) from api/index.ts.',
+    );
+    assertNotContains(
+      file,
+      content,
+      /\bcreateHandler\s*[:=]\s*(?!defineEffectBff\b)/u,
+      'API modules must not define unbranded handler factories; use defineEffectBff(...).',
+    );
+    assertNotContains(
+      file,
+      content,
+      /\bSchema\.(?:UnknownFromJsonString|Unknown|Any)\b/u,
+      'API modules must use concrete request, response and error schemas; Schema.UnknownFromJsonString, Schema.Unknown and Schema.Any are forbidden in UltraModern API code.',
+    );
+  }
+
+  assertNotContains(
+    file,
+    content,
+    /@modern-js\/plugin-bff\/hono-server/u,
+    'UltraModern API workspaces must not import Hono server helpers; use @modern-js/plugin-bff/effect-edge and HttpApi.',
+  );
+  assertNotContains(
+    file,
+    content,
+    /\bruntimeFramework\s*(?::|=)\s*['"]hono['"]/u,
+    'Generated UltraModern API apps must use the Effect runtime.',
+  );
+  assertNotContains(
+    file,
+    content,
+    /\bstrictEffectApproach\s*(?::|=)\s*false\b/u,
+    'Generated UltraModern API apps must keep strictEffectApproach enabled.',
+  );
+}
+
+const verticalDirectories = listDirectories('verticals');
+const shellClient = 'apps/shell-super-app/src/api/vertical-clients.ts';
+if (exists('apps/shell-super-app') && verticalDirectories.length > 0) {
+  assert(exists(shellClient), `${shellClient} must aggregate vertical API clients.`);
+}
+
+function assertApiSurface(appPath) {
+  const apiEntry = `${appPath}/api/index.ts`;
+  const sharedApi = `${appPath}/shared/api.ts`;
+  const srcApiDirectory = `${appPath}/src/api`;
+  const modernConfig = `${appPath}/modern.config.ts`;
+  const packageJsonPath = `${appPath}/package.json`;
+
+  assert(exists(apiEntry), `${apiEntry} is required.`);
+  assert(exists(sharedApi), `${sharedApi} is required.`);
+  assert(exists(srcApiDirectory), `${srcApiDirectory} is required.`);
+
+  if (exists(srcApiDirectory)) {
+    const clientFiles = listFiles(srcApiDirectory).filter(file =>
+      /-client\.ts$/u.test(file),
+    );
+    assert(
+      clientFiles.length > 0,
+      `${srcApiDirectory} must contain a generated API client.`,
+    );
+  }
+
+  if (exists(apiEntry)) {
+    const entry = readText(apiEntry);
+    assertContains(
+      apiEntry,
+      entry,
+      /\bdefineEffectBff\b/u,
+      'must export a defineEffectBff(...) runtime definition.',
+    );
+    assertContains(
+      apiEntry,
+      entry,
+      /\bHttpApiBuilder\b/u,
+      'must implement handlers through HttpApiBuilder.',
+    );
+    assertContains(
+      apiEntry,
+      entry,
+      /\bLayer\b/u,
+      'must compose dependencies with Effect Layer.',
+    );
+    assertContains(
+      apiEntry,
+      entry,
+      /from ['"]\.\.\/shared\/api\.ts['"]/u,
+      'must import the contract from ../shared/api.ts.',
+    );
+  }
+
+  if (exists(sharedApi)) {
+    const contract = readText(sharedApi);
+    assertContains(
+      sharedApi,
+      contract,
+      /\bHttpApi\.make\b/u,
+      'must declare the HttpApi contract.',
+    );
+    assertContains(
+      sharedApi,
+      contract,
+      /\bHttpApiGroup\.make\b/u,
+      'must declare HttpApi groups.',
+    );
+    assertContains(
+      sharedApi,
+      contract,
+      /\bHttpApiEndpoint\./u,
+      'must declare endpoints through HttpApiEndpoint.',
+    );
+    assertContains(
+      sharedApi,
+      contract,
+      /\bSchema\./u,
+      'must use Schema for request, response and error shapes.',
+    );
+  }
+
+  if (exists(modernConfig)) {
+    const config = readText(modernConfig);
+    assertContains(
+      modernConfig,
+      config,
+      /runtimeFramework:\s*['"]effect['"]/u,
+      'must use bff.runtimeFramework: effect.',
+    );
+    assertContains(
+      modernConfig,
+      config,
+      /entry:\s*['"]\.\/api\/index['"]/u,
+      'must point bff.effect.entry at ./api/index.',
+    );
+    assertContains(
+      modernConfig,
+      config,
+      /strictEffectApproach:\s*true/u,
+      'must enable strictEffectApproach explicitly.',
+    );
+  }
+
+  if (exists(packageJsonPath)) {
+    const packageJson = JSON.parse(readText(packageJsonPath));
+    assert(
+      packageJson.exports?.['./api'] === './shared/api.ts',
+      `${packageJsonPath}: package must export ./api from shared/api.ts.`,
+    );
+    assert(
+      typeof packageJson.exports?.['./api/client'] === 'string' &&
+        packageJson.exports['./api/client'].startsWith('./src/api/'),
+      `${packageJsonPath}: package must export ./api/client from src/api/*.`,
+    );
+  }
+}
+
+for (const appPath of listDirectories('apps')) {
+  if (exists(`${appPath}/api/index.ts`) || exists(`${appPath}/shared/api.ts`)) {
+    assertApiSurface(appPath);
+  }
+}
+
+for (const verticalPath of verticalDirectories) {
+  assertApiSurface(verticalPath);
+}
+
+if (exists('apps/shell-super-app/package.json')) {
+  const shellPackageJson = JSON.parse(
+    readText('apps/shell-super-app/package.json'),
+  );
+  assert(
+    shellPackageJson.exports?.['./api/clients'] ===
+      './src/api/vertical-clients.ts',
+    'apps/shell-super-app/package.json must export ./api/clients.',
+  );
+}
+
+if (exists('package.json')) {
+  const rootPackageJson = JSON.parse(readText('package.json'));
+  assert(
+    rootPackageJson.scripts?.['api:check'] ===
+      'node ./scripts/check-ultramodern-api-boundaries.mts',
+    'Root package.json must expose api:check.',
+  );
+  assert(
+    rootPackageJson.scripts?.check?.includes('pnpm api:check'),
+    'Root check script must include pnpm api:check.',
+  );
+}
+
+if (exists('topology/reference-topology.json')) {
+  const topology = JSON.parse(readText('topology/reference-topology.json'));
+  for (const vertical of topology.verticals ?? []) {
+    if (vertical.api?.runtime === 'effect') {
+      assert(
+        vertical.api.bff?.strictEffectApproach === true,
+        `${vertical.id} topology must mark strictEffectApproach as true.`,
+      );
+      assert(
+        typeof vertical.api.serverEntry === 'string' &&
+          vertical.api.serverEntry.endsWith('/api/index.ts'),
+        `${vertical.id} topology must use api/index.ts as the server entry.`,
+      );
+    }
+    assert(
+      !vertical.api?.effect,
+      `${vertical.id} topology must describe the API directly, not under api.effect.`,
+    );
+  }
+}
+
+if (failures.length > 0) {
+  console.error('UltraModern API boundary check failed:');
+  for (const failure of failures) {
+    console.error(`- ${failure}`);
+  }
+  process.exit(1);
+}
+
+console.log('UltraModern API boundary check passed.');

package/templates/workspace-scripts/{check-ultramodern-i18n-boundaries.mjs → check-ultramodern-i18n-boundaries.mts}

@@ -5,5 +5,5 @@ import { runWorkspaceSourceCheck } from '@modern-js/code-tools';
 const root = path.resolve(import.meta.dirname, '..');
 process.exitCode = runWorkspaceSourceCheck({
   cwd: root,
-  sourceRoots: ['apps', 'verticals'],
+  sourceRoots: ['apps', 'verticals', 'packages'],
 });