@trineui/cli 0.2.0 → 0.4.0

package/dist/project.js

@@ -1,17 +1,35 @@
-import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import ts from 'typescript';
-const STYLE_SOURCE_FILES = ['styles/tokens.css', 'styles/trine-consumer.css'];
-const STYLE_IMPORT_LINE = "@import './styles/trine-consumer.css';";
+const TRINE_BASELINE_START_LINE = '/* --- Trine styling baseline: start --- */';
+const TRINE_BASELINE_END_LINE = '/* --- Trine styling baseline: end --- */';
+const TRINE_BASELINE_TEMPLATE_FILE = 'styles/trine-baseline.css';
+const LEGACY_STYLE_IMPORT_LINES = [
+    "@import './styles/trine-consumer.css';",
+    '@import "./styles/trine-consumer.css";',
+];
+const AUTHORING_STYLE_IMPORT_LINES = [
+    "@import '@trine/ui/styles/trine.css';",
+    '@import "@trine/ui/styles/trine.css";',
+];
+const LEGACY_STYLE_FILES = ['src/styles/tokens.css', 'src/styles/trine-consumer.css'];
+const POSTCSS_CONFIG_FILE_NAMES = [
+    '.postcssrc.json',
+    '.postcssrc',
+    'postcss.config.js',
+    'postcss.config.cjs',
+    'postcss.config.mjs',
+];
 const CONVENTIONAL_STYLE_ENTRY_PATHS = ['src/styles.scss', 'src/styles.css', 'src/global.scss'];
 export const TEMPLATE_ROOT = fileURLToPath(new URL('../templates/', import.meta.url));
 const LOCAL_REPO_ROOT = path.resolve(TEMPLATE_ROOT, '../../..');
 export const LOCAL_REPO_DEMO_ROOT = path.resolve(TEMPLATE_ROOT, '../../../apps/demo');
-export function inspectProjectTarget(targetRoot) {
+export function inspectProjectTarget(targetRoot, options = {}) {
     const targetAppDir = path.join(targetRoot, 'src', 'app');
     const targetTsconfig = path.join(targetRoot, 'tsconfig.app.json');
-    const targetStylesEntry = resolveStylesEntry(targetRoot);
+    const targetStylesEntryCandidates = resolveStylesEntryCandidates(targetRoot);
+    const { targetStylesEntry, targetStylesEntryResolution } = resolveStylesEntrySelection(targetRoot, targetStylesEntryCandidates, options.preferredStylesEntry);
     const missingPaths = [];
     if (!existsSync(targetRoot)) {
         missingPaths.push(targetRoot);
@@ -30,13 +48,15 @@ export function inspectProjectTarget(targetRoot) {
         targetRoot,
         targetAppDir,
         targetTsconfig,
+        targetStylesEntryCandidates,
         targetStylesEntry,
+        targetStylesEntryResolution,
         framework,
         missingPaths,
     };
 }
-export function resolveSupportedProjectTarget(commandLabel, targetRoot) {
-    const inspection = inspectProjectTarget(targetRoot);
+export function resolveSupportedProjectTarget(commandLabel, targetRoot, options = {}) {
+    const inspection = inspectProjectTarget(targetRoot, options);
     if (inspection.framework === 'unsupported' || !inspection.targetStylesEntry) {
         throw new Error([
             `${commandLabel} requires a supported Angular or Ionic Angular app target with src/app, a global stylesheet entry, and tsconfig.app.json.`,
@@ -59,45 +79,20 @@ export function findAngularAppTargets(root) {
 export function looksLikeAngularAppRoot(root) {
     return inspectProjectTarget(root).framework !== 'unsupported';
 }
-export function ensureSharedStyleBaseline(targetRoot, componentLabel) {
-    const stylesDestDir = path.join(targetRoot, 'src', 'styles');
-    const createdFiles = [];
-    const reusedFiles = [];
-    const warnings = [];
-    mkdirSync(stylesDestDir, { recursive: true });
-    for (const sourceFile of STYLE_SOURCE_FILES) {
-        const templatePath = path.join(TEMPLATE_ROOT, sourceFile);
-        const destinationPath = path.join(stylesDestDir, path.basename(sourceFile));
-        const relativeDestination = toTargetRelativePath(targetRoot, destinationPath);
-        if (!existsSync(destinationPath)) {
-            copyFileSync(templatePath, destinationPath);
-            createdFiles.push(relativeDestination);
-            continue;
-        }
-        if (readFileSync(destinationPath, 'utf8') !== readFileSync(templatePath, 'utf8')) {
-            warnings.push(`${relativeDestination} already exists and was preserved. Review it manually if the delivered ${componentLabel} expects newer shared styling baseline content.`);
-            continue;
-        }
-        reusedFiles.push(relativeDestination);
-    }
-    return {
-        createdFiles,
-        reusedFiles,
-        warnings,
-    };
-}
 export function ensureUiRootBarrel(targetRoot) {
     const uiRootPath = path.join(targetRoot, 'src', 'app', 'components', 'ui', 'index.ts');
-    if (existsSync(uiRootPath)) {
-        return {
-            created: false,
-            file: toTargetRelativePath(targetRoot, uiRootPath),
-        };
+    const inspection = inspectUiRootBarrel(targetRoot);
+    if (!inspection.created) {
+        return inspection;
     }
     mkdirSync(path.dirname(uiRootPath), { recursive: true });
     writeFileSync(uiRootPath, '\n');
+    return inspection;
+}
+export function inspectUiRootBarrel(targetRoot) {
+    const uiRootPath = path.join(targetRoot, 'src', 'app', 'components', 'ui', 'index.ts');
     return {
-        created: true,
+        created: !existsSync(uiRootPath),
         file: toTargetRelativePath(targetRoot, uiRootPath),
     };
 }
@@ -122,6 +117,10 @@ export function ensureLinesFile(filePath, lines) {
     return changed;
 }
 export function ensureTsconfigAlias(tsconfigPath, targetRoot, cwd) {
+    const inspection = inspectTsconfigAlias(tsconfigPath, targetRoot, cwd);
+    if (!inspection.needsUpdate) {
+        return false;
+    }
     const currentText = readFileSync(tsconfigPath, 'utf8');
     const parsed = ts.parseConfigFileTextToJson(tsconfigPath, currentText);
     if (parsed.error) {
@@ -130,20 +129,7 @@ export function ensureTsconfigAlias(tsconfigPath, targetRoot, cwd) {
     const config = (parsed.config ?? {});
     config.compilerOptions ??= {};
     config.compilerOptions.paths ??= {};
-    const aliasTarget = isDemoTarget(targetRoot)
-        ? toPosixPath(path.relative(LOCAL_REPO_ROOT, path.join(targetRoot, 'src', 'app', 'components', 'ui', 'index.ts')))
-        : toConfigRelativePath(path.relative(path.dirname(tsconfigPath), path.join(targetRoot, 'src', 'app', 'components', 'ui', 'index.ts')));
-    const wildcardTarget = 'packages/ui/*';
-    const currentAlias = config.compilerOptions.paths['@trine/ui'];
-    const currentWildcardAlias = config.compilerOptions.paths['@trine/ui/*'];
-    const aliasIsCurrent = Array.isArray(currentAlias) && currentAlias.length === 1 && currentAlias[0] === aliasTarget;
-    const wildcardIsCurrent = !isDemoTarget(targetRoot) ||
-        (Array.isArray(currentWildcardAlias) &&
-            currentWildcardAlias.length === 1 &&
-            currentWildcardAlias[0] === wildcardTarget);
-    if (aliasIsCurrent && wildcardIsCurrent) {
-        return false;
-    }
+    const { aliasTarget, wildcardTarget } = buildAliasTargets(tsconfigPath, targetRoot);
     config.compilerOptions.paths['@trine/ui'] = [aliasTarget];
     if (isDemoTarget(targetRoot)) {
         config.compilerOptions.paths['@trine/ui/*'] = [wildcardTarget];
@@ -154,39 +140,75 @@ export function ensureTsconfigAlias(tsconfigPath, targetRoot, cwd) {
     writeFileSync(tsconfigPath, `${JSON.stringify(config, null, 2)}\n`);
     return true;
 }
-export function ensureStylesImport(stylesPath) {
-    const current = readFileSync(stylesPath, 'utf8');
-    if (current.includes(STYLE_IMPORT_LINE)) {
+export function inspectTsconfigAlias(tsconfigPath, targetRoot, cwd) {
+    const currentText = readFileSync(tsconfigPath, 'utf8');
+    const parsed = ts.parseConfigFileTextToJson(tsconfigPath, currentText);
+    if (parsed.error) {
+        throw new Error(`Unable to parse ${path.relative(cwd, tsconfigPath)} as JSONC.`);
+    }
+    const config = (parsed.config ?? {});
+    config.compilerOptions ??= {};
+    config.compilerOptions.paths ??= {};
+    const { aliasTarget, wildcardTarget } = buildAliasTargets(tsconfigPath, targetRoot);
+    const currentAlias = config.compilerOptions.paths['@trine/ui'];
+    const currentWildcardAlias = config.compilerOptions.paths['@trine/ui/*'];
+    const aliasIsCurrent = Array.isArray(currentAlias) && currentAlias.length === 1 && currentAlias[0] === aliasTarget;
+    const wildcardIsCurrent = !isDemoTarget(targetRoot) ||
+        (Array.isArray(currentWildcardAlias) &&
+            currentWildcardAlias.length === 1 &&
+            currentWildcardAlias[0] === wildcardTarget);
+    return {
+        needsUpdate: !(aliasIsCurrent && wildcardIsCurrent),
+    };
+}
+export function ensureTrineStylesheetBaseline(targetRoot, stylesPath) {
+    const inspection = inspectTrineStylesheetBaseline(targetRoot, stylesPath);
+    if (!inspection.needsUpdate) {
         return {
             updated: false,
-            authoringImportStillPresent: current.includes("@import '@trine/ui/styles/trine.css';"),
+            authoringImportStillPresent: inspection.authoringImportStillPresent,
+            warnings: inspection.warnings,
         };
     }
-    const lines = current.split('\n');
-    let insertAt = -1;
-    for (let index = 0; index < lines.length; index += 1) {
-        const trimmed = lines[index].trim();
-        if (trimmed.startsWith('@use') || trimmed.startsWith('@import')) {
-            insertAt = index;
-        }
-    }
-    if (insertAt === -1) {
-        lines.unshift(STYLE_IMPORT_LINE, '');
-    }
-    else {
-        lines.splice(insertAt + 1, 0, STYLE_IMPORT_LINE);
-    }
-    writeFileSync(stylesPath, lines.join('\n'));
+    const current = readFileSync(stylesPath, 'utf8');
+    const next = isDemoTarget(targetRoot)
+        ? buildDemoAuthoringStylesheet(current)
+        : buildConsumerInjectedStylesheet(current);
+    writeFileSync(stylesPath, next);
     return {
         updated: true,
-        authoringImportStillPresent: current.includes("@import '@trine/ui/styles/trine.css';"),
+        authoringImportStillPresent: isDemoTarget(targetRoot),
+        warnings: inspection.warnings,
+    };
+}
+export function inspectTrineStylesheetBaseline(targetRoot, stylesPath) {
+    const current = readFileSync(stylesPath, 'utf8');
+    const warnings = buildLegacyStyleWarnings(targetRoot);
+    const authoringImportStillPresent = containsExactImportLine(current, AUTHORING_STYLE_IMPORT_LINES);
+    if (isDemoTarget(targetRoot)) {
+        return {
+            needsUpdate: containsManagedBlock(current) ||
+                containsExactImportLine(current, LEGACY_STYLE_IMPORT_LINES) ||
+                !authoringImportStillPresent,
+            authoringImportStillPresent,
+            warnings,
+        };
+    }
+    const managedBlock = extractManagedBlock(current);
+    const expectedManagedBlock = buildManagedStylesheetBlock();
+    const hasLegacyImports = containsExactImportLine(current, LEGACY_STYLE_IMPORT_LINES) || authoringImportStillPresent;
+    const hasDuplicateTailwindImport = hasTailwindImportOutsideManagedBlock(current);
+    return {
+        needsUpdate: managedBlock !== expectedManagedBlock || hasLegacyImports || hasDuplicateTailwindImport,
+        authoringImportStillPresent,
+        warnings,
     };
 }
 export function readTargetDependencyWarnings(targetRoot, componentLabel) {
     const packageJsonPath = findNearestFileUpward(targetRoot, 'package.json');
     if (!packageJsonPath) {
         return [
-            'No package.json was found at or above the target root, so Tailwind CSS v4 and class-variance-authority prerequisites could not be checked automatically.',
+            'No package.json was found at or above the target root, so Tailwind CSS v4, PostCSS, and class-variance-authority prerequisites could not be checked automatically.',
         ];
     }
     try {
@@ -206,29 +228,42 @@ export function readTargetDependencyWarnings(targetRoot, componentLabel) {
         else if (!looksLikeTailwindV4(tailwindRange)) {
             warnings.push(`The target repo declares tailwindcss@${tailwindRange}. The current proven ${componentLabel} baseline expects Tailwind CSS v4.`);
         }
+        if (!deps['@tailwindcss/postcss']) {
+            warnings.push(`@tailwindcss/postcss is missing from the target repo. The current proven ${componentLabel} baseline expects it for Tailwind CSS v4 processing.`);
+        }
+        if (!deps['postcss']) {
+            warnings.push(`postcss is missing from the target repo. The current proven ${componentLabel} baseline expects it for Tailwind CSS v4 processing.`);
+        }
+        const postcssConfigPath = findNearestPostcssConfigPath(targetRoot);
+        if (!postcssConfigPath) {
+            warnings.push('No PostCSS config was found at or above the target root. The current proven baseline expects a PostCSS config that enables @tailwindcss/postcss.');
+        }
         return warnings;
     }
     catch {
         return [
-            `package.json could not be parsed for dependency checks. Verify Tailwind CSS v4 and class-variance-authority manually before building the delivered ${componentLabel}.`,
+            `package.json could not be parsed for dependency checks. Verify Tailwind CSS v4, PostCSS, and class-variance-authority manually before building the delivered ${componentLabel}.`,
         ];
     }
 }
 export function resolveStylesEntry(targetRoot) {
+    return inspectProjectTarget(targetRoot).targetStylesEntry;
+}
+export function resolveStylesEntryCandidates(targetRoot) {
+    const candidates = new Set();
     for (const relativePath of CONVENTIONAL_STYLE_ENTRY_PATHS) {
         const absolutePath = path.join(targetRoot, relativePath);
         if (existsSync(absolutePath)) {
-            return absolutePath;
+            candidates.add(absolutePath);
         }
     }
     const angularJsonPaths = findFilesUpward(targetRoot, 'angular.json');
     for (const angularJsonPath of angularJsonPaths) {
-        const resolvedFromWorkspace = resolveStylesEntryFromAngularWorkspace(angularJsonPath, targetRoot);
-        if (resolvedFromWorkspace) {
-            return resolvedFromWorkspace;
+        for (const resolvedFromWorkspace of resolveStylesEntriesFromAngularWorkspace(angularJsonPath, targetRoot)) {
+            candidates.add(resolvedFromWorkspace);
         }
     }
-    return undefined;
+    return [...candidates];
 }
 export function isDemoTarget(targetRoot) {
     return (existsSync(LOCAL_REPO_DEMO_ROOT) &&
@@ -287,7 +322,7 @@ function packageJsonUsesIonicAngular(packageJsonPath) {
         return false;
     }
 }
-function resolveStylesEntryFromAngularWorkspace(angularJsonPath, targetRoot) {
+function resolveStylesEntriesFromAngularWorkspace(angularJsonPath, targetRoot) {
     try {
         const angularJson = JSON.parse(readFileSync(angularJsonPath, 'utf8'));
         const workspaceRoot = path.dirname(angularJsonPath);
@@ -298,6 +333,7 @@ function resolveStylesEntryFromAngularWorkspace(angularJsonPath, targetRoot) {
             : path.resolve(targetRoot) === path.resolve(workspaceRoot)
                 ? projects
                 : [];
+        const matches = [];
         for (const project of candidateProjects) {
             const styles = project.architect?.build?.options?.styles ?? project.targets?.build?.options?.styles ?? [];
             for (const style of styles) {
@@ -307,15 +343,15 @@ function resolveStylesEntryFromAngularWorkspace(angularJsonPath, targetRoot) {
                 }
                 const absolutePath = path.resolve(workspaceRoot, input);
                 if (existsSync(absolutePath)) {
-                    return absolutePath;
+                    matches.push(absolutePath);
                 }
             }
         }
+        return matches;
     }
     catch {
-        return undefined;
+        return [];
     }
-    return undefined;
 }
 function projectMatchesTargetRoot(project, workspaceRoot, targetRoot) {
     const resolvedTargetRoot = path.resolve(targetRoot);
@@ -355,7 +391,198 @@ function findFilesUpward(startDir, fileName) {
 function findNearestFileUpward(startDir, fileName) {
     return findFilesUpward(startDir, fileName)[0];
 }
+function findNearestPostcssConfigPath(startDir) {
+    for (const fileName of POSTCSS_CONFIG_FILE_NAMES) {
+        const match = findNearestFileUpward(startDir, fileName);
+        if (match) {
+            return match;
+        }
+    }
+    return undefined;
+}
 function looksLikeTailwindV4(range) {
     const versionTokenPattern = /(?:^|[<>=~^|\s:])v?(\d+)(?:(?:\.\d+){0,2})/g;
     return [...range.matchAll(versionTokenPattern)].some((match) => Number(match[1]) === 4);
 }
+function buildAliasTargets(tsconfigPath, targetRoot) {
+    const aliasTarget = isDemoTarget(targetRoot)
+        ? toPosixPath(path.relative(LOCAL_REPO_ROOT, path.join(targetRoot, 'src', 'app', 'components', 'ui', 'index.ts')))
+        : toConfigRelativePath(path.relative(path.dirname(tsconfigPath), path.join(targetRoot, 'src', 'app', 'components', 'ui', 'index.ts')));
+    const wildcardTarget = 'packages/ui/*';
+    return {
+        aliasTarget,
+        wildcardTarget,
+    };
+}
+function resolveStylesEntrySelection(targetRoot, candidates, preferredStylesEntry) {
+    if (preferredStylesEntry) {
+        const preferredAbsolutePath = path.resolve(targetRoot, preferredStylesEntry);
+        if (candidates.includes(preferredAbsolutePath)) {
+            return {
+                targetStylesEntry: preferredAbsolutePath,
+                targetStylesEntryResolution: 'preferred',
+            };
+        }
+    }
+    const managedBlockCandidates = candidates.filter((candidate) => {
+        try {
+            return containsManagedBlock(readFileSync(candidate, 'utf8'));
+        }
+        catch {
+            return false;
+        }
+    });
+    if (managedBlockCandidates.length === 1) {
+        return {
+            targetStylesEntry: managedBlockCandidates[0],
+            targetStylesEntryResolution: 'managed-block',
+        };
+    }
+    const legacyImportCandidates = candidates.filter((candidate) => {
+        try {
+            return containsExactImportLine(readFileSync(candidate, 'utf8'), LEGACY_STYLE_IMPORT_LINES);
+        }
+        catch {
+            return false;
+        }
+    });
+    if (legacyImportCandidates.length === 1) {
+        return {
+            targetStylesEntry: legacyImportCandidates[0],
+            targetStylesEntryResolution: 'legacy-import',
+        };
+    }
+    const authoringImportCandidates = candidates.filter((candidate) => {
+        try {
+            return containsExactImportLine(readFileSync(candidate, 'utf8'), AUTHORING_STYLE_IMPORT_LINES);
+        }
+        catch {
+            return false;
+        }
+    });
+    if (authoringImportCandidates.length === 1) {
+        return {
+            targetStylesEntry: authoringImportCandidates[0],
+            targetStylesEntryResolution: 'authoring-import',
+        };
+    }
+    if (candidates.length > 0) {
+        return {
+            targetStylesEntry: candidates[0],
+            targetStylesEntryResolution: 'default',
+        };
+    }
+    return {
+        targetStylesEntry: undefined,
+        targetStylesEntryResolution: 'none',
+    };
+}
+function buildManagedStylesheetBlock() {
+    const templatePath = path.join(TEMPLATE_ROOT, TRINE_BASELINE_TEMPLATE_FILE);
+    const templateContent = readFileSync(templatePath, 'utf8').trimEnd();
+    return `${TRINE_BASELINE_START_LINE}\n${templateContent}\n${TRINE_BASELINE_END_LINE}`;
+}
+function containsManagedBlock(current) {
+    return current.includes(TRINE_BASELINE_START_LINE) && current.includes(TRINE_BASELINE_END_LINE);
+}
+function extractManagedBlock(current) {
+    const match = current.match(new RegExp(`${escapeRegExp(TRINE_BASELINE_START_LINE)}[\\s\\S]*?${escapeRegExp(TRINE_BASELINE_END_LINE)}`));
+    return match?.[0];
+}
+function stripManagedBlock(current) {
+    return current.replace(new RegExp(`\\n?${escapeRegExp(TRINE_BASELINE_START_LINE)}[\\s\\S]*?${escapeRegExp(TRINE_BASELINE_END_LINE)}\\n?`, 'g'), '\n');
+}
+function buildConsumerInjectedStylesheet(current) {
+    const withoutManagedBlock = stripManagedBlock(current);
+    const withoutLegacyImports = removeExactImportLines(removeExactImportLines(withoutManagedBlock, LEGACY_STYLE_IMPORT_LINES), AUTHORING_STYLE_IMPORT_LINES);
+    const withoutTailwindImports = removeTailwindImports(withoutLegacyImports);
+    return insertManagedBlock(withoutTailwindImports, buildManagedStylesheetBlock());
+}
+function buildDemoAuthoringStylesheet(current) {
+    const withoutManagedBlock = stripManagedBlock(current);
+    const withoutLegacyImports = removeExactImportLines(withoutManagedBlock, LEGACY_STYLE_IMPORT_LINES);
+    if (containsExactImportLine(withoutLegacyImports, AUTHORING_STYLE_IMPORT_LINES)) {
+        return normalizeStylesheetText(withoutLegacyImports);
+    }
+    return insertManagedBlock(withoutLegacyImports, AUTHORING_STYLE_IMPORT_LINES[0]);
+}
+function removeExactImportLines(current, importsToRemove) {
+    return current
+        .split('\n')
+        .filter((line) => !importsToRemove.includes(line.trim()))
+        .join('\n');
+}
+function removeTailwindImports(current) {
+    return current
+        .split('\n')
+        .filter((line) => !isTailwindImportLine(line.trim()))
+        .join('\n');
+}
+function containsExactImportLine(current, candidates) {
+    return current.split('\n').some((line) => candidates.includes(line.trim()));
+}
+function hasTailwindImportOutsideManagedBlock(current) {
+    return stripManagedBlock(current)
+        .split('\n')
+        .some((line) => isTailwindImportLine(line.trim()));
+}
+function isTailwindImportLine(line) {
+    return (line === "@import 'tailwindcss';" ||
+        line === '@import "tailwindcss";' ||
+        line === "@import url('tailwindcss');" ||
+        line === '@import url("tailwindcss");');
+}
+function insertManagedBlock(current, block) {
+    const normalized = normalizeStylesheetText(current);
+    if (normalized.trim() === '') {
+        return `${block}\n`;
+    }
+    const lines = normalized.split('\n');
+    let insertAt = 0;
+    for (let index = 0; index < lines.length; index += 1) {
+        const trimmed = lines[index].trim();
+        if (isPreludeLine(trimmed)) {
+            insertAt = index + 1;
+            continue;
+        }
+        break;
+    }
+    const before = lines.slice(0, insertAt).join('\n').trimEnd();
+    const after = lines.slice(insertAt).join('\n').trimStart();
+    return joinSections(before, block, after);
+}
+function joinSections(...sections) {
+    const populatedSections = sections.filter((section) => section.trim() !== '');
+    if (populatedSections.length === 0) {
+        return '\n';
+    }
+    return `${populatedSections.join('\n\n').trimEnd()}\n`;
+}
+function isPreludeLine(trimmedLine) {
+    return (trimmedLine === '' ||
+        trimmedLine.startsWith('//') ||
+        trimmedLine.startsWith('/*') ||
+        trimmedLine.startsWith('*') ||
+        trimmedLine.startsWith('*/') ||
+        trimmedLine.startsWith('@charset') ||
+        trimmedLine.startsWith('@use') ||
+        trimmedLine.startsWith('@forward') ||
+        trimmedLine.startsWith('@import'));
+}
+function normalizeStylesheetText(current) {
+    return current
+        .replace(/\r\n/g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+function buildLegacyStyleWarnings(targetRoot) {
+    return listLegacyStyleFiles(targetRoot).map((file) => `${file} still exists from the older separate-file Trine baseline. The injected global stylesheet model no longer requires it, so remove it manually when you no longer need it.`);
+}
+function listLegacyStyleFiles(targetRoot) {
+    return LEGACY_STYLE_FILES.map((relativePath) => path.join(targetRoot, relativePath))
+        .filter((filePath) => existsSync(filePath))
+        .map((filePath) => toTargetRelativePath(targetRoot, filePath));
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/prompt.js

@@ -0,0 +1,59 @@
+import process from 'node:process';
+import { createInterface } from 'node:readline/promises';
+export async function chooseFromList(message, items, options = {}) {
+    assertInteractiveTerminal();
+    if (items.length === 0) {
+        throw new Error('Cannot choose from an empty list.');
+    }
+    if (items.length === 1) {
+        return items[0];
+    }
+    const renderItem = options.renderItem ?? ((item, index) => `${String(index + 1)}. ${item}`);
+    console.log(message);
+    for (const [index, item] of items.entries()) {
+        console.log(renderItem(item, index));
+    }
+    const prompt = createPrompt();
+    try {
+        for (;;) {
+            const answer = (await prompt.question(`Choose an option [1-${String(items.length)}]: `)).trim();
+            const selectedIndex = Number(answer);
+            if (Number.isInteger(selectedIndex) && selectedIndex >= 1 && selectedIndex <= items.length) {
+                return items[selectedIndex - 1];
+            }
+            console.log(`Enter a number between 1 and ${String(items.length)}.`);
+        }
+    }
+    finally {
+        prompt.close();
+    }
+}
+export async function confirmAction(message) {
+    assertInteractiveTerminal();
+    const prompt = createPrompt();
+    try {
+        const answer = (await prompt.question(`${message} `)).trim().toLowerCase();
+        if (answer === '' || answer === 'y' || answer === 'yes') {
+            return true;
+        }
+        if (answer === 'n' || answer === 'no') {
+            return false;
+        }
+        console.log('Enter Y, yes, N, or no.');
+        return await confirmAction(message);
+    }
+    finally {
+        prompt.close();
+    }
+}
+export function assertInteractiveTerminal() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error('trine init default mode is guided and needs an interactive terminal. Re-run with --yes for non-interactive mode.');
+    }
+}
+function createPrompt() {
+    return createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trineui/cli",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "type": "module",
   "description": "Copy-paste ownership CLI for Trine UI components.",
   "main": "./dist/index.js",