@bleedingdev/modern-js-create 3.2.0-ultramodern.2 → 3.2.0-ultramodern.20

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

@@ -0,0 +1,95 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const root = process.cwd();
+const lockPath = path.join(root, '.agents/skills-lock.json');
+const checkOnly = process.argv.includes('--check');
+const force = process.argv.includes('--force');
+
+const readJson = (filePath) => JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+
+const run = (command, args, options = {}) =>
+  execFileSync(command, args, {
+    cwd: options.cwd ?? root,
+    encoding: 'utf-8',
+    stdio: options.stdio ?? ['ignore', 'pipe', 'pipe'],
+  });
+
+const cloneSource = (source, targetDir) => {
+  const repo = source.repository.replace(/^https:\/\/github.com\//u, '');
+  try {
+    run('gh', ['repo', 'clone', repo, targetDir, '--', '--depth', '1'], {
+      stdio: 'inherit',
+    });
+  } catch {
+    run('git', ['clone', '--depth', '1', source.repository, targetDir], {
+      stdio: 'inherit',
+    });
+  }
+};
+
+const resolveSkillDir = (sourceRoot, skillName) => {
+  const candidates = [
+    path.join(sourceRoot, skillName),
+    path.join(sourceRoot, 'skills', skillName),
+    path.join(sourceRoot, 'skills', 'engineering', skillName),
+    path.join(sourceRoot, 'skills', 'productivity', skillName),
+  ];
+  return candidates.find((candidate) => fs.existsSync(path.join(candidate, 'SKILL.md')));
+};
+
+if (!fs.existsSync(lockPath)) {
+  console.error('Missing .agents/skills-lock.json');
+  process.exit(1);
+}
+
+const lock = readJson(lockPath);
+const installDir = path.join(root, lock.installDir ?? '.agents/skills');
+const privateSources = (lock.sources ?? []).filter(
+  (source) => source.install === 'clone-if-authorized',
+);
+
+if (checkOnly) {
+  const missing = privateSources.flatMap((source) =>
+    (source.baseline ?? [])
+      .map((skill) => skill.name)
+      .filter((skillName) => !fs.existsSync(path.join(installDir, skillName, 'SKILL.md'))),
+  );
+  if (missing.length > 0) {
+    console.warn(
+      `Private skills not installed: ${missing.join(', ')}. Run pnpm skills:install if you have access.`,
+    );
+  } else {
+    console.log('Agent skills are installed.');
+  }
+  process.exit(0);
+}
+
+fs.mkdirSync(installDir, { recursive: true });
+
+for (const source of privateSources) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ultramodern-skills-'));
+  try {
+    cloneSource(source, tempDir);
+    for (const skill of source.baseline ?? []) {
+      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;
+        }
+        fs.rmSync(targetSkillDir, { force: true, recursive: true });
+      }
+      fs.cpSync(sourceSkillDir, targetSkillDir, { recursive: true });
+      console.log(`Installed ${skill.name}`);
+    }
+  } finally {
+    fs.rmSync(tempDir, { force: true, recursive: true });
+  }
+}

package/template-workspace/scripts/check-i18n-strings.mjs

@@ -0,0 +1,83 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const root = process.cwd();
+const scanRoots = ['apps'].map((scanRoot) => path.join(root, scanRoot));
+const ignoredDirectories = new Set(['.modern', '.modernjs', 'dist', 'node_modules']);
+const visibleAttributePattern =
+  /\s(?:aria-label|alt|placeholder|title)=["']([^"']*[A-Za-z][^"']*)["']/gu;
+const jsxTextPattern = />([^<>{}]*[A-Za-z][^<>{}]*)</gu;
+
+const collectFiles = (directory) => {
+  if (!fs.existsSync(directory)) {
+    return [];
+  }
+
+  const files = [];
+  for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      if (!ignoredDirectories.has(entry.name)) {
+        files.push(...collectFiles(path.join(directory, entry.name)));
+      }
+      continue;
+    }
+
+    if (entry.isFile() && /\.(jsx|tsx)$/u.test(entry.name) && !entry.name.endsWith('.d.ts')) {
+      files.push(path.join(directory, entry.name));
+    }
+  }
+  return files;
+};
+
+const lineNumberForIndex = (content, index) => content.slice(0, index).split('\n').length;
+const isIgnoredLine = (content, index) => {
+  const lineStart = content.lastIndexOf('\n', index) + 1;
+  const lineEnd = content.indexOf('\n', index);
+  const currentLineEnd = lineEnd === -1 ? content.length : lineEnd;
+  const previousLineStart = content.lastIndexOf('\n', Math.max(0, lineStart - 2)) + 1;
+  const nextLineEnd = content.indexOf('\n', currentLineEnd + 1);
+  const context = content.slice(
+    previousLineStart,
+    nextLineEnd === -1 ? content.length : nextLineEnd,
+  );
+  return /i18n-ignore/u.test(context);
+};
+
+const violations = [];
+for (const filePath of scanRoots.flatMap(collectFiles)) {
+  const content = fs.readFileSync(filePath, 'utf-8');
+  for (const match of content.matchAll(visibleAttributePattern)) {
+    if (!isIgnoredLine(content, match.index ?? 0)) {
+      violations.push({
+        filePath,
+        line: lineNumberForIndex(content, match.index ?? 0),
+        text: match[1].trim(),
+      });
+    }
+  }
+
+  for (const match of content.matchAll(jsxTextPattern)) {
+    const text = match[1].replaceAll(/\s+/gu, ' ').trim();
+    if (text && !isIgnoredLine(content, match.index ?? 0)) {
+      violations.push({
+        filePath,
+        line: lineNumberForIndex(content, match.index ?? 0),
+        text,
+      });
+    }
+  }
+}
+
+if (violations.length > 0) {
+  console.error('Hardcoded user-visible JSX strings found. Move copy to locale JSON files.');
+  for (const violation of violations) {
+    console.error(
+      `${path.relative(root, violation.filePath)}:${violation.line} ${JSON.stringify(
+        violation.text,
+      )}`,
+    );
+  }
+  process.exit(1);
+}
+
+console.log('No hardcoded user-visible JSX strings found.');

package/template-workspace/scripts/setup-agent-reference-repos.mjs

@@ -0,0 +1,217 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const root = process.cwd();
+const args = new Set(process.argv.slice(2));
+const checkOnly = args.has('--check');
+const configPath = path.join(root, '.agents', 'agent-reference-repos.json');
+const manifestPath = path.join(root, '.modernjs', 'agent-reference-repos.json');
+const tempRoot = path.join(root, '.modernjs', 'agent-reference-repos-tmp');
+
+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_REPOS) ||
+  falsy(process.env.ULTRAMODERN_AGENT_REPOS);
+const required = truthy(process.env.ULTRAMODERN_AGENT_REPOS_REQUIRED);
+const refresh = truthy(process.env.ULTRAMODERN_AGENT_REPOS_REFRESH);
+
+const log = message => console.log(`[agent-reference-repos] ${message}`);
+const warn = message => console.warn(`[agent-reference-repos] ${message}`);
+
+function fail(message) {
+  if (required || checkOnly) {
+    throw new Error(message);
+  }
+  warn(message);
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+}
+
+function run(command, commandArgs, options = {}) {
+  const result = spawnSync(command, commandArgs, {
+    cwd: options.cwd ?? root,
+    encoding: 'utf-8',
+    stdio: options.stdio ?? ['ignore', 'pipe', 'pipe'],
+    timeout: options.timeout ?? 120000,
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    const stderr = result.stderr?.trim();
+    throw new Error(
+      `${command} ${commandArgs.join(' ')} failed${
+        stderr ? `: ${stderr}` : ''
+      }`,
+    );
+  }
+  return result.stdout?.trim() ?? '';
+}
+
+function assertSafeRepoPath(relativePath) {
+  if (
+    typeof relativePath !== 'string' ||
+    relativePath.length === 0 ||
+    path.isAbsolute(relativePath) ||
+    relativePath.split(/[\\/]+/).includes('..') ||
+    !relativePath.startsWith('repos/')
+  ) {
+    throw new Error(`Unsafe reference repository path: ${relativePath}`);
+  }
+}
+
+function hasGit() {
+  const result = spawnSync('git', ['--version'], {
+    encoding: 'utf-8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  return result.status === 0;
+}
+
+function existingReference(targetPath, repo) {
+  const markerPath = path.join(targetPath, '.ultramodern-reference-repo.json');
+  if (!fs.existsSync(markerPath)) {
+    return undefined;
+  }
+  try {
+    const marker = readJson(markerPath);
+    if (marker.url === repo.url && marker.ref === repo.ref) {
+      return marker;
+    }
+  } catch {
+    return undefined;
+  }
+  return undefined;
+}
+
+function materializeRepository(repo) {
+  assertSafeRepoPath(repo.path);
+  const targetPath = path.join(root, repo.path);
+  const existing = existingReference(targetPath, repo);
+
+  if (existing && !refresh) {
+    log(`${repo.id} already present at ${repo.path} (${existing.commit})`);
+    return { ...existing, status: 'present' };
+  }
+
+  if (fs.existsSync(targetPath)) {
+    if (!refresh) {
+      fail(`${repo.path} exists but is not a managed reference repo`);
+      return undefined;
+    }
+    fs.rmSync(targetPath, { recursive: true, force: true });
+  }
+
+  if (checkOnly) {
+    fail(`${repo.path} is missing`);
+    return undefined;
+  }
+
+  fs.mkdirSync(tempRoot, { recursive: true });
+  const tempPath = fs.mkdtempSync(path.join(tempRoot, `${repo.id}-`));
+
+  try {
+    log(`cloning ${repo.name} from ${repo.url}#${repo.ref}`);
+    run(
+      'git',
+      [
+        'clone',
+        '--depth',
+        '1',
+        '--single-branch',
+        '--branch',
+        repo.ref,
+        '--filter=blob:none',
+        repo.url,
+        tempPath,
+      ],
+      { timeout: 300000 },
+    );
+    const commit = run('git', ['-C', tempPath, 'rev-parse', 'HEAD']);
+    fs.rmSync(path.join(tempPath, '.git'), { recursive: true, force: true });
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    fs.renameSync(tempPath, targetPath);
+
+    const marker = {
+      schemaVersion: 1,
+      id: repo.id,
+      name: repo.name,
+      url: repo.url,
+      ref: repo.ref,
+      commit,
+      path: repo.path,
+      readOnly: repo.readOnly !== false,
+      installedAt: new Date().toISOString(),
+    };
+    fs.writeFileSync(
+      path.join(targetPath, '.ultramodern-reference-repo.json'),
+      `${JSON.stringify(marker, null, 2)}\n`,
+    );
+    log(`${repo.id} installed at ${repo.path} (${commit})`);
+    return { ...marker, status: 'installed' };
+  } catch (error) {
+    fs.rmSync(tempPath, { recursive: true, force: true });
+    fail(`Could not install ${repo.id}: ${error.message}`);
+    return undefined;
+  }
+}
+
+function main() {
+  if (!fs.existsSync(configPath)) {
+    fail('Missing .agents/agent-reference-repos.json');
+    return;
+  }
+
+  const config = readJson(configPath);
+  const enabled = config.defaultEnabled !== false && !skipRequested;
+
+  if (!enabled) {
+    log('setup skipped; set ULTRAMODERN_SKIP_AGENT_REPOS=0 to enable it again');
+    return;
+  }
+
+  if (!hasGit()) {
+    fail('git is required to install agent reference repositories');
+    return;
+  }
+
+  const installed = [];
+  for (const repo of config.repositories ?? []) {
+    const result = materializeRepository(repo);
+    if (result) {
+      installed.push(result);
+    }
+  }
+
+  if (!checkOnly) {
+    fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+    fs.writeFileSync(
+      manifestPath,
+      `${JSON.stringify(
+        {
+          schemaVersion: 1,
+          generatedAt: new Date().toISOString(),
+          installDir: config.installDir ?? 'repos',
+          repositories: installed,
+        },
+        null,
+        2,
+      )}\n`,
+    );
+  }
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(`[agent-reference-repos] ${error.message}`);
+  process.exitCode = 1;
+} finally {
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+}