@bleedingdev/modern-js-create 3.2.0-ultramodern.12 → 3.2.0-ultramodern.121

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

@@ -7,26 +7,122 @@ 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 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);
+const cloneTimeoutMs = Number.parseInt(
+  process.env.ULTRAMODERN_AGENT_SKILLS_CLONE_TIMEOUT_MS ?? '60000',
+  10,
+);
 
-const readJson = (filePath) => JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+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'],
+    timeout: options.timeout,
+  });
+
+const commandExists = command => {
+  try {
+    run(command, ['--version'], { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const requireGit = () => {
+  if (commandExists('git')) {
+    return;
+  }
+
+  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.',
+  );
+};
+
+const isInsideGitWorkTree = () => {
+  try {
+    return run('git', ['rev-parse', '--is-inside-work-tree']).trim() === 'true';
+  } catch {
+    return false;
+  }
+};
+
+const initializeGitRepository = () => {
+  if (isInsideGitWorkTree()) {
+    return;
+  }
+
+  try {
+    run('git', ['init', '-b', 'main'], { stdio: 'inherit' });
+  } catch {
+    run('git', ['init'], { stdio: 'inherit' });
+    run('git', ['branch', '-M', 'main'], { stdio: 'inherit' });
+  }
+};
+
+const installLefthook = () => {
+  try {
+    run('lefthook', ['install'], { stdio: 'inherit' });
+  } catch (error) {
+    console.warn(`Unable to install lefthook hooks: ${error.message}`);
+  }
+};
+
+const removeTree = dir =>
+  fs.rmSync(dir, {
+    force: true,
+    maxRetries: 5,
+    recursive: true,
+    retryDelay: 100,
   });
 
 const cloneSource = (source, targetDir) => {
+  if (source.commit) {
+    run('git', ['init', targetDir], { timeout: 30000 });
+    run('git', ['remote', 'add', 'origin', source.repository], {
+      cwd: targetDir,
+      timeout: 30000,
+    });
+    run('git', ['fetch', '--depth', '1', '--quiet', 'origin', source.commit], {
+      cwd: targetDir,
+      timeout: cloneTimeoutMs,
+    });
+    run(
+      'git',
+      [
+        '-c',
+        'advice.detachedHead=false',
+        'checkout',
+        '--detach',
+        '--quiet',
+        'FETCH_HEAD',
+      ],
+      { cwd: targetDir, timeout: 30000 },
+    );
+    return;
+  }
+
   const repo = source.repository.replace(/^https:\/\/github.com\//u, '');
   try {
-    run('gh', ['repo', 'clone', repo, targetDir, '--', '--depth', '1'], {
-      stdio: 'inherit',
-    });
+    run(
+      'gh',
+      ['repo', 'clone', repo, targetDir, '--', '--depth', '1', '--quiet'],
+      { timeout: cloneTimeoutMs },
+    );
   } catch {
-    run('git', ['clone', '--depth', '1', source.repository, targetDir], {
-      stdio: 'inherit',
-    });
+    run(
+      'git',
+      ['clone', '--depth', '1', '--quiet', source.repository, targetDir],
+      { timeout: cloneTimeoutMs },
+    );
   }
 };
 
@@ -37,7 +133,9 @@ const resolveSkillDir = (sourceRoot, skillName) => {
     path.join(sourceRoot, 'skills', 'engineering', skillName),
     path.join(sourceRoot, 'skills', 'productivity', skillName),
   ];
-  return candidates.find((candidate) => fs.existsSync(path.join(candidate, 'SKILL.md')));
+  return candidates.find(candidate =>
+    fs.existsSync(path.join(candidate, 'SKILL.md')),
+  );
 };
 
 if (!fs.existsSync(lockPath)) {
@@ -47,36 +145,99 @@ if (!fs.existsSync(lockPath)) {
 
 const lock = readJson(lockPath);
 const installDir = path.join(root, lock.installDir ?? '.agents/skills');
-const privateSources = (lock.sources ?? []).filter(
-  (source) => source.install === 'clone-if-authorized',
+const sources = lock.sources ?? [];
+const requiredCloneSources = 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 vendoredRequiredSkills = (lock.baseline ?? []).filter(
+  skill => !cloneSourceSkillNames.has(skill.name),
+);
+const cloneOptIn = truthy(process.env.ULTRAMODERN_AGENT_SKILLS);
+
+if (skipRequested) {
+  const reason = 'agent skills bootstrap skipped by environment';
+  if (checkOnly) {
+    console.log(reason);
+    process.exit(0);
+  }
+  console.log(reason);
+  installLefthook();
+  process.exit(0);
+}
 
 if (checkOnly) {
-  const missing = privateSources.flatMap((source) =>
+  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'))),
+      .map(skill => skill.name)
+      .filter(
+        skillName =>
+          !fs.existsSync(path.join(installDir, skillName, 'SKILL.md')),
+      ),
   );
-  if (missing.length > 0) {
+
+  if (missingVendored.length > 0) {
+    console.error(
+      `Required agent skills not installed: ${missingVendored.join(', ')}. Run pnpm skills:install.`,
+    );
+    process.exit(1);
+  }
+
+  if (missingCloneInstalled.length > 0) {
     console.warn(
-      `Private skills not installed: ${missing.join(', ')}. Run pnpm skills:install if you have access.`,
+      `Clone-installed agent skills not present: ${missingCloneInstalled.join(', ')}. Run pnpm skills:install to fetch them.`,
     );
   } else {
-    console.log('Agent skills are installed.');
+    console.log('All pinned agent skills are installed.');
   }
   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 });
+requireGit();
+initializeGitRepository();
 
-for (const source of privateSources) {
+for (const source of [...requiredCloneSources, ...optionalCloneSources]) {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ultramodern-skills-'));
   try {
-    cloneSource(source, tempDir);
+    try {
+      cloneSource(source, tempDir);
+    } catch (error) {
+      if (source.install === 'clone-if-authorized' || postinstall) {
+        console.warn(`Skipping ${source.repository}; ${error.message}`);
+        continue;
+      }
+      throw error;
+    }
     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}`);
+        throw new Error(
+          `Skill ${skill.name} not found in ${source.repository}`,
+        );
       }
       const targetSkillDir = path.join(installDir, skill.name);
       if (fs.existsSync(targetSkillDir)) {
@@ -84,12 +245,14 @@ for (const source of privateSources) {
           console.log(`Skipping existing ${skill.name}`);
           continue;
         }
-        fs.rmSync(targetSkillDir, { force: true, recursive: true });
+        removeTree(targetSkillDir);
       }
       fs.cpSync(sourceSkillDir, targetSkillDir, { recursive: true });
       console.log(`Installed ${skill.name}`);
     }
   } finally {
-    fs.rmSync(tempDir, { force: true, recursive: true });
+    removeTree(tempDir);
   }
 }
+
+installLefthook();

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

@@ -0,0 +1,370 @@
+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 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 gitIdentityEnv = {
+  GIT_AUTHOR_NAME:
+    process.env.GIT_AUTHOR_NAME || 'UltraModern Agent Reference Setup',
+  GIT_AUTHOR_EMAIL:
+    process.env.GIT_AUTHOR_EMAIL || 'ultramodern-agent-refs@local',
+  GIT_COMMITTER_NAME:
+    process.env.GIT_COMMITTER_NAME || 'UltraModern Agent Reference Setup',
+  GIT_COMMITTER_EMAIL:
+    process.env.GIT_COMMITTER_EMAIL || 'ultramodern-agent-refs@local',
+};
+
+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',
+    env: {
+      ...process.env,
+      ...gitIdentityEnv,
+      ...(options.env ?? {}),
+    },
+    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 hasGitSubtree() {
+  const result = spawnSync('git', ['subtree', '-h'], {
+    encoding: 'utf-8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  return (
+    (result.status === 0 || result.status === 129) &&
+    result.stdout.includes('usage: git subtree')
+  );
+}
+
+function isGitWorkTree() {
+  const result = spawnSync('git', ['rev-parse', '--is-inside-work-tree'], {
+    cwd: root,
+    encoding: 'utf-8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  return result.status === 0 && result.stdout.trim() === 'true';
+}
+
+function hasCommits() {
+  const result = spawnSync('git', ['rev-parse', '--verify', 'HEAD'], {
+    cwd: root,
+    encoding: 'utf-8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  return result.status === 0;
+}
+
+function porcelainStatus() {
+  return run('git', ['status', '--porcelain'], { timeout: 30000 });
+}
+
+function commitInstallerChanges(message) {
+  run('git', ['commit', '--no-verify', '-m', message], {
+    timeout: 120000,
+  });
+}
+
+function ensureGitRepository() {
+  if (!isGitWorkTree()) {
+    if (checkOnly) {
+      fail('workspace is not a git repository');
+      return false;
+    }
+    log('initializing git repository for agent reference subtrees');
+    run('git', ['init'], { timeout: 30000 });
+  }
+
+  if (!hasCommits()) {
+    if (checkOnly) {
+      fail('workspace has no initial git commit');
+      return false;
+    }
+    log('creating initial workspace commit before adding reference subtrees');
+    run('git', ['add', '-A'], { timeout: 30000 });
+    commitInstallerChanges('Initialize UltraModern workspace');
+    return true;
+  }
+
+  const status = porcelainStatus();
+  if (status) {
+    fail(
+      'workspace has uncommitted changes; commit or stash them before installing reference subtrees',
+    );
+    return false;
+  }
+
+  return true;
+}
+
+function remoteCommit(repo) {
+  let output = run('git', ['ls-remote', repo.url, `refs/heads/${repo.ref}`], {
+    timeout: 120000,
+  });
+  if (!output) {
+    output = run('git', ['ls-remote', repo.url, repo.ref], {
+      timeout: 120000,
+    });
+  }
+  const [commit] = output.split(/\s+/);
+  if (!/^[a-f0-9]{40}$/i.test(commit ?? '')) {
+    throw new Error(`Could not resolve ${repo.url}#${repo.ref}`);
+  }
+  return commit;
+}
+
+function subtreeCommitExists(repo) {
+  const result = spawnSync(
+    'git',
+    [
+      'log',
+      '--grep',
+      `git-subtree-dir: ${repo.path}`,
+      '--format=%H',
+      '-n',
+      '1',
+    ],
+    {
+      cwd: root,
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  );
+  return result.status === 0 && result.stdout.trim().length > 0;
+}
+
+function installedManifestEntry(repo) {
+  if (!fs.existsSync(manifestPath)) {
+    return undefined;
+  }
+  try {
+    const manifest = readJson(manifestPath);
+    return manifest.repositories?.find(entry => entry.id === repo.id);
+  } catch {
+    return undefined;
+  }
+}
+
+function assertSubtreePresent(repo) {
+  assertSafeRepoPath(repo.path);
+  const targetPath = path.join(root, repo.path);
+  if (!fs.existsSync(targetPath)) {
+    fail(`${repo.path} is missing`);
+    return undefined;
+  }
+  if (!subtreeCommitExists(repo)) {
+    fail(`${repo.path} is present but has no git-subtree commit evidence`);
+    return undefined;
+  }
+  return (
+    installedManifestEntry(repo) ?? {
+      id: repo.id,
+      name: repo.name,
+      url: repo.url,
+      ref: repo.ref,
+      path: repo.path,
+      readOnly: repo.readOnly !== false,
+      status: 'present',
+      strategy: 'git-subtree-squash',
+    }
+  );
+}
+
+function addSubtree(repo) {
+  assertSafeRepoPath(repo.path);
+  const targetPath = path.join(root, repo.path);
+  const existing = fs.existsSync(targetPath);
+
+  if (existing && !refresh) {
+    return assertSubtreePresent(repo);
+  }
+
+  if (existing && refresh) {
+    fail(
+      `${repo.path} already exists; refresh for subtree references is intentionally manual`,
+    );
+    return undefined;
+  }
+
+  if (checkOnly) {
+    fail(`${repo.path} is missing`);
+    return undefined;
+  }
+
+  const commit = remoteCommit(repo);
+  log(`adding ${repo.name} as git subtree at ${repo.path} (${commit})`);
+  run('git', ['fetch', '--depth', '1', repo.url, repo.ref], {
+    timeout: 300000,
+  });
+  run(
+    'git',
+    [
+      'subtree',
+      'add',
+      '--prefix',
+      repo.path,
+      'FETCH_HEAD',
+      '--squash',
+      '-m',
+      `Add ${repo.name} agent reference repo`,
+    ],
+    { timeout: 600000 },
+  );
+
+  return {
+    schemaVersion: 1,
+    id: repo.id,
+    name: repo.name,
+    url: repo.url,
+    ref: repo.ref,
+    commit,
+    path: repo.path,
+    readOnly: repo.readOnly !== false,
+    strategy: 'git-subtree-squash',
+    status: 'installed',
+    installedAt: new Date().toISOString(),
+  };
+}
+
+function writeManifest(entries) {
+  fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+  fs.writeFileSync(
+    manifestPath,
+    `${JSON.stringify(
+      {
+        schemaVersion: 1,
+        generatedAt: new Date().toISOString(),
+        strategy: 'git-subtree-squash',
+        installDir: 'repos',
+        repositories: entries,
+      },
+      null,
+      2,
+    )}\n`,
+  );
+}
+
+function commitManifestIfChanged() {
+  const status = run('git', ['status', '--porcelain', '--', manifestPath], {
+    timeout: 30000,
+  });
+  if (!status) {
+    return;
+  }
+  run('git', ['add', manifestPath], { timeout: 30000 });
+  commitInstallerChanges('Record agent reference repo manifest');
+}
+
+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;
+  }
+  if (!hasGitSubtree()) {
+    fail('git subtree is required to install agent reference repositories');
+    return;
+  }
+  if (!ensureGitRepository()) {
+    return;
+  }
+
+  const entries = [];
+  for (const repo of config.repositories ?? []) {
+    const result = checkOnly ? assertSubtreePresent(repo) : addSubtree(repo);
+    if (result) {
+      entries.push(result);
+    }
+  }
+
+  if (!checkOnly) {
+    writeManifest(entries);
+    commitManifestIfChanged();
+  }
+}
+
+try {
+  main();
+} catch (error) {
+  if (required || checkOnly) {
+    console.error(`[agent-reference-repos] ${error.message}`);
+    process.exitCode = 1;
+  } else {
+    warn(error.message);
+  }
+}

package/templates/app/shell-frame.tsx

@@ -0,0 +1,49 @@
+import { useLocalizedLocation, useModernI18n } from '@modern-js/plugin-i18n/runtime';
+import type { ReactNode } from 'react';
+import { Header, StatusBadge } from './vertical-components';
+
+interface ShellFrameProps {
+  children: ReactNode;
+}
+
+export default function ShellFrame({ children }: ShellFrameProps) {
+  const { i18nInstance, language } = useModernI18n();
+  const t = i18nInstance['t'].bind(i18nInstance);
+  const { alternates } = useLocalizedLocation();
+
+  return (
+    <main className="shell:min-h-screen shell:bg-um-canvas shell:px-4 shell:py-5 shell:text-um-foreground shell:sm:px-6 shell:lg:px-12">
+      <div className="shell:mx-auto shell:flex shell:min-h-20 shell:max-w-7xl shell:flex-col shell:items-start shell:gap-3 shell:bg-white/90 shell:px-4 shell:py-3 shell:shadow-xl shell:shadow-stone-900/10 shell:sm:px-6 shell:md:flex-row shell:md:flex-wrap shell:md:items-center shell:md:justify-between">
+        <Header />
+        <div className="shell:flex shell:min-w-0 shell:flex-wrap shell:items-center shell:gap-2 shell:md:ml-auto">
+          <label className="shell:sr-only" htmlFor="ultramodern-language">
+            {t('shell.language.switcher')}
+          </label>
+          <select
+            aria-label={t('shell.language.switcher')}
+            className="shell:h-10 shell:w-10 shell:cursor-pointer shell:appearance-none shell:border-0 shell:bg-transparent shell:p-0 shell:text-center shell:text-3xl shell:font-black shell:leading-none shell:text-stone-950 shell:shadow-none shell:[appearance:none] shell:[text-align-last:center] shell:focus-visible:rounded-md shell:focus-visible:outline-3 shell:focus-visible:outline-offset-2 shell:focus-visible:outline-emerald-700/40 shell:[&::-ms-expand]:hidden shell:[&::picker-icon]:hidden shell:[&_option]:text-xl"
+            id="ultramodern-language"
+            name="language"
+            onChange={event => {
+              const nextLanguage = event.currentTarget.value;
+              const targetHref = alternates[nextLanguage];
+              if (targetHref !== undefined) {
+                window.location.assign(targetHref);
+              }
+            }}
+            value={language}
+          >
+            <option aria-label={t('shell.language.en')} value="en">
+              🇬🇧
+            </option>
+            <option aria-label={t('shell.language.cs')} value="cs">
+              🇨🇿
+            </option>
+          </select>
+          <StatusBadge />
+        </div>
+      </div>
+      {children}
+    </main>
+  );
+}