create-aztec-privacy-template 0.1.0

package/dist/cli.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { printUsage } from './helpers/cli-options.js';
+import { run } from './index.js';
+run(process.argv.slice(2), import.meta.url).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    printUsage();
+    process.exit(1);
+});

package/dist/constants.js

@@ -0,0 +1,35 @@
+export const SUPPORTED_PACKAGE_MANAGERS = ['bun', 'npm', 'pnpm', 'yarn'];
+export const SCAFFOLD_DIR = 'scaffold';
+export const OVERLAY_EXAMPLES_DIR = 'overlays/examples';
+export const EXAMPLE_OVERLAY_ORDER = ['aave', 'lido', 'uniswap'];
+export const SUPPORTED_EXAMPLE_SELECTIONS = ['none', ...EXAMPLE_OVERLAY_ORDER, 'all'];
+export const TEMPLATE_COPY_ENTRIES = [
+    '.solhint.json',
+    'gitignore',
+    'Makefile',
+    'README.md',
+    'contracts',
+    'scripts',
+];
+export const PLACEHOLDER_TEXT_FILES = ['README.md'];
+export const STARTER_PACKAGE_JSON_BASE = {
+    private: true,
+    version: '0.1.0',
+    description: 'Protocol-agnostic starter for Aztec privacy integrations',
+    license: 'MIT',
+    scripts: {
+        fmt: 'make fmt',
+        'fmt:check': 'make fmt-check',
+        lint: 'make lint',
+        test: 'make test',
+    },
+    devDependencies: {
+        solhint: '^6.0.3',
+    },
+};
+export const INSTALL_COMMANDS = {
+    bun: 'bun install',
+    npm: 'npm install',
+    pnpm: 'pnpm install',
+    yarn: 'yarn install',
+};

package/dist/create-app.js

@@ -0,0 +1,50 @@
+import { relative } from 'node:path';
+import { installExampleSource } from './helpers/examples.js';
+import { tryGitInit } from './helpers/git.js';
+import { installDependencies } from './helpers/install.js';
+import { runPostInitHooks } from './helpers/post-init.js';
+import { scaffoldTemplate } from './helpers/template-scaffold.js';
+import { assertTargetPathSafe, resolveProjectTarget } from './validate.js';
+export async function createApp(options, dependencies = {}) {
+    const { generatorRoot, projectArg, packageManager, exampleSelection, exampleSource, skipInstall = false, disableGit = false, } = options;
+    const install = dependencies.install ?? installDependencies;
+    const postInit = dependencies.postInit ?? runPostInitHooks;
+    const gitInit = dependencies.gitInit ?? tryGitInit;
+    const installRemoteExample = dependencies.installExampleSource ?? installExampleSource;
+    const { absoluteTargetPath, projectName } = resolveProjectTarget(projectArg);
+    assertTargetPathSafe(absoluteTargetPath);
+    await scaffoldTemplate({
+        generatorRoot,
+        absoluteTargetPath,
+        projectName,
+        packageManager,
+        exampleSelection,
+    });
+    const remoteExample = exampleSource
+        ? await installRemoteExample({
+            absoluteTargetPath,
+            exampleSource,
+        })
+        : undefined;
+    if (!skipInstall) {
+        await install({
+            packageManager,
+            cwd: absoluteTargetPath,
+        });
+    }
+    await postInit({
+        absoluteTargetPath,
+        exampleSelection,
+        installedDependencies: !skipInstall,
+    });
+    const gitInitialized = disableGit ? false : gitInit(absoluteTargetPath);
+    return {
+        absoluteTargetPath,
+        displayPath: relative(process.cwd(), absoluteTargetPath) || absoluteTargetPath,
+        packageManager,
+        projectName,
+        installedDependencies: !skipInstall,
+        gitInitialized,
+        remoteExample,
+    };
+}

package/dist/helpers/cli-options.js

@@ -0,0 +1,108 @@
+import { assertExampleSelection, assertExampleSource, assertPackageManager } from '../validate.js';
+export function printUsage() {
+    console.log('Usage: create-aztec-privacy-template <project-name-or-path> [--pm <bun|npm|pnpm|yarn>] [--example <none|aave|lido|uniswap|all>] [--example-source <github-url|owner/repo[/path][#ref]>] [--yes] [--skip-install] [--disable-git]');
+}
+export function parseArgs(argv) {
+    let projectArg = '';
+    let packageManager = 'npm';
+    let exampleSelection = 'none';
+    let exampleSource;
+    let yes = false;
+    let skipInstall = false;
+    let disableGit = false;
+    let packageManagerProvided = false;
+    let exampleSelectionProvided = false;
+    let exampleSourceProvided = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === '--help' || arg === '-h') {
+            printUsage();
+            process.exit(0);
+        }
+        if (arg === '--yes') {
+            yes = true;
+            continue;
+        }
+        if (arg === '--skip-install') {
+            skipInstall = true;
+            continue;
+        }
+        if (arg === '--disable-git') {
+            disableGit = true;
+            continue;
+        }
+        if (arg === '--pm') {
+            const value = argv[i + 1];
+            if (!value) {
+                throw new Error('--pm requires a value');
+            }
+            assertPackageManager(value);
+            packageManager = value;
+            packageManagerProvided = true;
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith('--pm=')) {
+            const value = arg.slice('--pm='.length);
+            assertPackageManager(value);
+            packageManager = value;
+            packageManagerProvided = true;
+            continue;
+        }
+        if (arg === '--example') {
+            const value = argv[i + 1];
+            if (!value) {
+                throw new Error('--example requires a value');
+            }
+            assertExampleSelection(value);
+            exampleSelection = value;
+            exampleSelectionProvided = true;
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith('--example=')) {
+            const value = arg.slice('--example='.length);
+            assertExampleSelection(value);
+            exampleSelection = value;
+            exampleSelectionProvided = true;
+            continue;
+        }
+        if (arg === '--example-source') {
+            const value = argv[i + 1];
+            if (!value) {
+                throw new Error('--example-source requires a value');
+            }
+            assertExampleSource(value);
+            exampleSource = value;
+            exampleSourceProvided = true;
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith('--example-source=')) {
+            const value = arg.slice('--example-source='.length);
+            assertExampleSource(value);
+            exampleSource = value;
+            exampleSourceProvided = true;
+            continue;
+        }
+        if (arg.startsWith('-')) {
+            throw new Error(`Unknown option: ${arg}`);
+        }
+        if (projectArg) {
+            throw new Error(`Unexpected extra argument: ${arg}`);
+        }
+        projectArg = arg;
+    }
+    return {
+        projectArg: projectArg || undefined,
+        packageManager,
+        exampleSelection,
+        exampleSource,
+        yes,
+        skipInstall,
+        disableGit,
+        packageManagerProvided,
+        exampleSelectionProvided,
+        exampleSourceProvided,
+    };
+}

package/dist/helpers/examples.js

@@ -0,0 +1,264 @@
+import { spawn } from 'node:child_process';
+import { cp, mkdtemp, mkdir, readdir, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, resolve, sep } from 'node:path';
+const DEFAULT_RETRY_ATTEMPTS = 3;
+const DEFAULT_RETRY_DELAY_MS = 400;
+const GITHUB_HOSTS = new Set(['github.com', 'www.github.com']);
+const GITHUB_TOKEN_PATTERN = /^[A-Za-z0-9._-]+$/;
+const defaultDependencies = {
+    fetchImpl: fetch,
+    extractArchive: extractTarArchive,
+    sleep: wait,
+};
+export async function installExampleSource(options, dependencies = defaultDependencies) {
+    const parsedSource = parseGithubExampleSource(options.exampleSource);
+    const maxAttempts = normalizeRetryAttempts(options.maxAttempts);
+    const retryDelayMs = normalizeRetryDelay(options.retryDelayMs);
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        try {
+            await downloadAndApplyExampleSource({
+                absoluteTargetPath: options.absoluteTargetPath,
+                parsedSource,
+                dependencies,
+            });
+            return {
+                source: parsedSource.normalizedSource,
+                applied: true,
+                attempts: attempt,
+            };
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt < maxAttempts) {
+                await dependencies.sleep(retryDelayMs * attempt);
+            }
+        }
+    }
+    return {
+        source: parsedSource.normalizedSource,
+        applied: false,
+        attempts: maxAttempts,
+        fallbackReason: formatErrorMessage(lastError),
+    };
+}
+export function parseGithubExampleSource(source) {
+    const trimmed = source.trim();
+    if (!trimmed) {
+        throw new Error('Example source cannot be empty.');
+    }
+    if (trimmed.startsWith('http://') || trimmed.startsWith('https://')) {
+        return parseGithubUrlSource(trimmed);
+    }
+    return parseGithubRepoSource(trimmed);
+}
+async function downloadAndApplyExampleSource({ absoluteTargetPath, parsedSource, dependencies, }) {
+    const tempRoot = await mkdtemp(join(tmpdir(), 'capt-example-source-'));
+    const archivePath = join(tempRoot, 'source.tar.gz');
+    const extractDir = join(tempRoot, 'extract');
+    try {
+        await mkdir(extractDir, { recursive: true });
+        await downloadArchive(parsedSource, archivePath, dependencies.fetchImpl);
+        await dependencies.extractArchive(archivePath, extractDir);
+        const extractedRoot = await findExtractedRoot(extractDir);
+        const sourcePath = resolveSourcePath(extractedRoot, parsedSource.subPath);
+        const sourceStats = await stat(sourcePath);
+        if (!sourceStats.isDirectory()) {
+            throw new Error(`Remote source path is not a directory: ${parsedSource.subPath || '.'}`);
+        }
+        await cp(sourcePath, absoluteTargetPath, {
+            recursive: true,
+            errorOnExist: false,
+            force: true,
+            preserveTimestamps: true,
+        });
+    }
+    finally {
+        await rm(tempRoot, { recursive: true, force: true });
+    }
+}
+async function downloadArchive(parsedSource, archivePath, fetchImpl) {
+    const archiveUrl = buildArchiveUrl(parsedSource);
+    const response = await fetchImpl(archiveUrl, {
+        redirect: 'follow',
+        headers: {
+            'user-agent': 'create-aztec-privacy-template',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`GitHub archive request failed (${response.status} ${response.statusText}).`);
+    }
+    const archiveBuffer = Buffer.from(await response.arrayBuffer());
+    await writeFile(archivePath, archiveBuffer);
+}
+function buildArchiveUrl(parsedSource) {
+    const { owner, repo, ref } = parsedSource;
+    return `https://codeload.github.com/${owner}/${repo}/tar.gz/${encodeURIComponent(ref)}`;
+}
+async function extractTarArchive(archivePath, extractDir) {
+    await new Promise((resolvePromise, reject) => {
+        const child = spawn('tar', ['-xzf', archivePath, '-C', extractDir], {
+            stdio: 'ignore',
+        });
+        child.on('error', (error) => {
+            reject(new Error(`Failed to extract remote archive: ${error.message}`));
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolvePromise();
+                return;
+            }
+            reject(new Error(`Failed to extract remote archive (tar exited with code ${code ?? 'unknown'}).`));
+        });
+    });
+}
+async function findExtractedRoot(extractDir) {
+    const entries = await readdir(extractDir, { withFileTypes: true });
+    const rootEntry = entries.find((entry) => entry.isDirectory());
+    if (!rootEntry) {
+        throw new Error('Remote archive extraction produced no files.');
+    }
+    return join(extractDir, rootEntry.name);
+}
+function resolveSourcePath(extractedRoot, subPath) {
+    if (!subPath) {
+        return extractedRoot;
+    }
+    const candidate = resolve(extractedRoot, subPath);
+    if (candidate === extractedRoot || candidate.startsWith(`${extractedRoot}${sep}`)) {
+        return candidate;
+    }
+    throw new Error('Remote source path escapes extracted archive.');
+}
+function parseGithubUrlSource(rawSource) {
+    if (rawSource.trim().endsWith('#')) {
+        throw new Error('GitHub source ref cannot be empty after "#".');
+    }
+    const url = new URL(rawSource);
+    if (!GITHUB_HOSTS.has(url.hostname)) {
+        throw new Error('Example source URL must point to github.com.');
+    }
+    const segments = url.pathname
+        .split('/')
+        .filter(Boolean)
+        .map((segment) => decodeURIComponent(segment));
+    if (segments.length < 2) {
+        throw new Error('GitHub example URL must include owner and repository.');
+    }
+    const owner = validateGitHubToken(segments[0], 'owner');
+    const repo = validateGitHubToken(stripGitSuffix(segments[1]), 'repository');
+    const refFromHash = parseUrlHashRef(url);
+    let ref = refFromHash ?? 'HEAD';
+    let subPath = '';
+    if (segments[2] === 'tree') {
+        if (!segments[3]) {
+            throw new Error('GitHub tree URL must include a branch or tag.');
+        }
+        ref = refFromHash ?? segments[3];
+        subPath = segments.slice(4).join('/');
+    }
+    else if (segments.length > 2) {
+        subPath = segments.slice(2).join('/');
+    }
+    return toParsedGithubSource(owner, repo, ref, subPath);
+}
+function parseGithubRepoSource(rawSource) {
+    const hashIndex = rawSource.indexOf('#');
+    let mainPart = rawSource;
+    let refFromHash;
+    if (hashIndex !== -1) {
+        mainPart = rawSource.slice(0, hashIndex);
+        refFromHash = rawSource.slice(hashIndex + 1).trim();
+        if (!refFromHash) {
+            throw new Error('GitHub source ref cannot be empty after "#".');
+        }
+    }
+    const segments = mainPart
+        .split('/')
+        .filter(Boolean)
+        .map((segment) => decodeURIComponent(segment));
+    if (segments.length < 2) {
+        throw new Error('GitHub repo source must use "<owner>/<repo>" format.');
+    }
+    const owner = validateGitHubToken(segments[0], 'owner');
+    const repo = validateGitHubToken(stripGitSuffix(segments[1]), 'repository');
+    let ref = refFromHash ?? 'HEAD';
+    let subPath = '';
+    if (segments[2] === 'tree') {
+        if (!segments[3]) {
+            throw new Error('GitHub tree source must include a branch or tag.');
+        }
+        ref = refFromHash ?? segments[3];
+        subPath = segments.slice(4).join('/');
+    }
+    else if (segments.length > 2) {
+        subPath = segments.slice(2).join('/');
+    }
+    return toParsedGithubSource(owner, repo, ref, subPath);
+}
+function validateGitHubToken(value, label) {
+    if (GITHUB_TOKEN_PATTERN.test(value)) {
+        return value;
+    }
+    throw new Error(`Invalid GitHub ${label} in example source: "${value}".`);
+}
+function stripGitSuffix(repo) {
+    return repo.endsWith('.git') ? repo.slice(0, -4) : repo;
+}
+function parseUrlHashRef(url) {
+    if (!url.hash) {
+        return undefined;
+    }
+    const rawRef = url.hash.slice(1).trim();
+    if (!rawRef) {
+        throw new Error('GitHub source ref cannot be empty after "#".');
+    }
+    try {
+        return decodeURIComponent(rawRef);
+    }
+    catch {
+        throw new Error('GitHub source ref is not valid URL encoding.');
+    }
+}
+function toParsedGithubSource(owner, repo, ref, subPath) {
+    const normalizedRef = ref.trim() || 'HEAD';
+    const normalizedSubPath = subPath.replace(/^\/+|\/+$/g, '');
+    const suffix = normalizedSubPath ? `/${normalizedSubPath}` : '';
+    return {
+        owner,
+        repo,
+        ref: normalizedRef,
+        subPath: normalizedSubPath,
+        normalizedSource: `https://github.com/${owner}/${repo}/tree/${normalizedRef}${suffix}`,
+    };
+}
+function normalizeRetryAttempts(value) {
+    if (value === undefined) {
+        return DEFAULT_RETRY_ATTEMPTS;
+    }
+    if (!Number.isInteger(value) || value < 1) {
+        throw new Error('maxAttempts must be a positive integer.');
+    }
+    return value;
+}
+function normalizeRetryDelay(value) {
+    if (value === undefined) {
+        return DEFAULT_RETRY_DELAY_MS;
+    }
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error('retryDelayMs must be a non-negative number.');
+    }
+    return value;
+}
+function formatErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+async function wait(delayMs) {
+    await new Promise((resolvePromise) => {
+        setTimeout(resolvePromise, delayMs);
+    });
+}

package/dist/helpers/git.js

@@ -0,0 +1,73 @@
+import { execSync } from 'node:child_process';
+import { join } from 'node:path';
+import { rmSync } from 'node:fs';
+function isInsideGitRepository(cwd) {
+    try {
+        execSync('git rev-parse --is-inside-work-tree', { cwd, stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isInsideMercurialRepository(cwd) {
+    try {
+        execSync('hg --cwd . root', { cwd, stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function hasGitBinary() {
+    try {
+        execSync('git --version', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function hasDefaultBranchConfig(cwd) {
+    try {
+        execSync('git config init.defaultBranch', { cwd, stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function tryGitInit(root) {
+    if (!hasGitBinary()) {
+        return false;
+    }
+    if (isInsideGitRepository(root) || isInsideMercurialRepository(root)) {
+        return false;
+    }
+    let initialized = false;
+    try {
+        execSync('git init', { cwd: root, stdio: 'ignore' });
+        initialized = true;
+        if (!hasDefaultBranchConfig(root)) {
+            // Use branch -M so this remains safe if HEAD is already "main".
+            execSync('git branch -M main', { cwd: root, stdio: 'ignore' });
+        }
+        execSync('git add -A', { cwd: root, stdio: 'ignore' });
+        execSync('git commit -m "Initial commit from create-aztec-privacy-template"', {
+            cwd: root,
+            stdio: 'ignore',
+        });
+        return true;
+    }
+    catch {
+        if (initialized) {
+            try {
+                rmSync(join(root, '.git'), { recursive: true, force: true });
+            }
+            catch {
+                // Ignore cleanup failures after a failed git init attempt.
+            }
+        }
+        return false;
+    }
+}

package/dist/helpers/install.js

@@ -0,0 +1,36 @@
+import { spawn } from 'node:child_process';
+export async function installDependencies(options) {
+    const { packageManager, cwd } = options;
+    const args = ['install'];
+    const env = {
+        ...process.env,
+        NODE_ENV: 'development',
+    };
+    if (packageManager === 'yarn') {
+        // Yarn Berry enables immutable installs on CI by default, which blocks
+        // first-time lockfile generation in freshly scaffolded projects.
+        env.YARN_ENABLE_IMMUTABLE_INSTALLS = 'false';
+    }
+    await new Promise((resolve, reject) => {
+        const child = spawn(packageManager, args, {
+            cwd,
+            stdio: 'inherit',
+            env,
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`Dependency install failed: ${packageManager} ${args.join(' ')} (exit code ${code ?? 'unknown'})`));
+        });
+        child.on('error', (error) => {
+            const spawnError = error;
+            if (spawnError.code === 'ENOENT') {
+                reject(new Error(`Package manager "${packageManager}" is not installed or not available on PATH. Install it or rerun with --pm <bun|npm|pnpm|yarn>.`));
+                return;
+            }
+            reject(new Error(`Failed to spawn installer ${packageManager}: ${error.message}`));
+        });
+    });
+}

package/dist/helpers/post-init.js

@@ -0,0 +1,33 @@
+import { access, chmod } from 'node:fs/promises';
+import { join } from 'node:path';
+const POST_INIT_HOOKS = [
+    verifyRequiredLayoutHook,
+    ensureCompileScriptExecutableHook,
+];
+export async function runPostInitHooks(context) {
+    for (const hook of POST_INIT_HOOKS) {
+        await hook(context);
+    }
+}
+async function verifyRequiredLayoutHook(context) {
+    const requiredPaths = [
+        'README.md',
+        'package.json',
+        join('contracts', 'l1'),
+        join('contracts', 'aztec'),
+        join('scripts', 'compile-aztec-contract.sh'),
+    ];
+    if (context.exampleSelection === 'all') {
+        requiredPaths.push(join('examples', 'aave'), join('examples', 'lido'), join('examples', 'uniswap'));
+    }
+    else if (context.exampleSelection !== 'none') {
+        requiredPaths.push(join('examples', context.exampleSelection));
+    }
+    for (const relativePath of requiredPaths) {
+        await access(join(context.absoluteTargetPath, relativePath));
+    }
+}
+async function ensureCompileScriptExecutableHook(context) {
+    const compileScript = join(context.absoluteTargetPath, 'scripts', 'compile-aztec-contract.sh');
+    await chmod(compileScript, 0o755);
+}

package/dist/helpers/template-scaffold.js

@@ -0,0 +1,18 @@
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { STARTER_PACKAGE_JSON_BASE, } from '../constants.js';
+import { applyPlaceholdersInSelectedFiles, assertNoUnresolvedPlaceholders, getPlaceholderMap, } from '../placeholders.js';
+import { installTemplatePlan, resolveTemplateInstallPlan } from '../templates/index.js';
+export async function scaffoldTemplate(options) {
+    const { generatorRoot, absoluteTargetPath, projectName, packageManager, exampleSelection = 'none', } = options;
+    const templatePlan = resolveTemplateInstallPlan(generatorRoot, exampleSelection);
+    await installTemplatePlan(absoluteTargetPath, templatePlan);
+    const packageJson = {
+        ...STARTER_PACKAGE_JSON_BASE,
+        name: projectName,
+    };
+    await writeFile(join(absoluteTargetPath, 'package.json'), `${JSON.stringify(packageJson, null, 2)}\n`, 'utf8');
+    const placeholderMap = getPlaceholderMap(projectName, packageManager);
+    await applyPlaceholdersInSelectedFiles(absoluteTargetPath, placeholderMap);
+    await assertNoUnresolvedPlaceholders(absoluteTargetPath);
+}

package/dist/index.js

@@ -0,0 +1,50 @@
+import { INSTALL_COMMANDS } from './constants.js';
+import { createApp } from './create-app.js';
+import { parseArgs } from './helpers/cli-options.js';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { resolvePromptOptions } from './prompts.js';
+export async function run(argv, importMetaUrl) {
+    const parsedArgs = parseArgs(argv);
+    const args = await resolvePromptOptions(parsedArgs);
+    const generatorRoot = resolveGeneratorRoot(importMetaUrl);
+    const result = await createApp({
+        generatorRoot,
+        projectArg: args.projectArg,
+        packageManager: args.packageManager,
+        exampleSelection: args.exampleSelection,
+        exampleSource: args.exampleSource,
+        skipInstall: args.skipInstall,
+        disableGit: args.disableGit,
+    });
+    console.log(`\nScaffolded Aztec privacy starter at ${result.displayPath}`);
+    if (result.gitInitialized) {
+        console.log('Initialized a git repository.');
+    }
+    else if (args.disableGit) {
+        console.log('Skipped git initialization.');
+    }
+    else {
+        console.log('Git initialization was skipped (git unavailable or commit failed).');
+    }
+    if (result.remoteExample) {
+        if (result.remoteExample.applied) {
+            console.log(`Applied remote example source: ${result.remoteExample.source}`);
+        }
+        else {
+            const reason = result.remoteExample.fallbackReason
+                ? ` (${result.remoteExample.fallbackReason})`
+                : '';
+            console.log(`Remote example source unavailable${reason}. Falling back to local built-in examples.`);
+        }
+    }
+    console.log('\nNext steps:');
+    console.log(`  cd ${result.displayPath}`);
+    if (!result.installedDependencies) {
+        console.log(`  ${INSTALL_COMMANDS[result.packageManager]}`);
+    }
+    console.log('  make check');
+}
+function resolveGeneratorRoot(importMetaUrl) {
+    return resolve(dirname(fileURLToPath(importMetaUrl)), '..');
+}