@trineui/cli 0.2.0 → 0.3.0

package/README.md

@@ -16,17 +16,22 @@ Registry status note:
 Repository-local current command surface:
 
 ```bash
-trine init --target <app-root>
+trine init [--target <app-root>] [--yes]
 trine add button --target <app-root>
 ```
 
 Notes:
 
 - `init` is now the preferred first step for project readiness; `add button` still works without it for backward compatibility
+- `init` is guided by default: it detects the target, surfaces warnings, previews file changes, and asks for confirmation before mutation
+- `init --yes` keeps a non-interactive fast path for automation and scripting
 - `button` is the only supported component in this public-style baseline
 - omitting `--target` uses the current directory when it already matches the supported Angular app shape
 - when the current directory is not a supported Angular app target, the CLI auto-detects a single Angular app target under the current directory and proceeds automatically
-- when multiple Angular app targets are found, the CLI stops and asks for `--target <app-root>`
+- when multiple Angular app targets are found, guided `init` lets the user choose one interactively
+- when multiple Angular app targets are found, `init --yes` and `add button` fail clearly and ask for `--target <app-root>`
+- when multiple plausible stylesheet entries are found, guided `init` lets the user choose one interactively
+- when multiple plausible stylesheet entries are found, `init --yes` fails clearly and asks the user to rerun without `--yes`
 - external targets can run `trine add button` from the app root or pass an explicit app root such as `--target /absolute/path/to/angular-app`
 - `init` detects `angular` and `ionic-angular` targets conservatively; unsupported targets fail clearly
 - the canonical public package name is `@trineui/cli`
@@ -36,6 +41,7 @@ Notes:
 - packaged/public-style proof uses a packed local tarball to simulate `npx @trineui/cli@latest add button`
 - the packaged CLI ships compiled runtime files plus Button templates so it can execute from `node_modules` in a real `npx`-style flow
 - `init` ensures `src/styles/tokens.css`, `src/styles/trine-consumer.css`, `src/app/components/ui/index.ts`, the local `@trine/ui` alias, and local stylesheet wiring
+- rerunning `init` on an already prepared target exits cleanly with a no-op summary instead of prompting again
 - consumer-owned component destination files cause a clear failure
 - existing shared baseline files (`tokens.css` and `trine-consumer.css`) are preserved so a second component can be added into the same target repo
 - the command copies consumer-owned source instead of wiring runtime back to `packages/ui`

package/dist/index.js

@@ -1,23 +1,26 @@
 #!/usr/bin/env node
 import path from 'node:path';
 import { addButton } from "./add-button.js";
-import { initProject } from "./init.js";
-import { findAngularAppTargets, looksLikeAngularAppRoot } from "./project.js";
+import { applyInitPlan, planInitProject } from "./init.js";
+import { chooseFromList, confirmAction } from "./prompt.js";
+import { findAngularAppTargets, inspectProjectTarget, looksLikeAngularAppRoot } from "./project.js";
 const HELP_TEXT = `Usage:
-  npx @trineui/cli@latest init [--target <app-root>]
+  npx @trineui/cli@latest init [--target <app-root>] [--yes]
   npx @trineui/cli@latest add button [--target <app-root>]
-  trine init [--target <app-root>]
+  trine init [--target <app-root>] [--yes]
   trine add button [--target <app-root>]
 
 Defaults:
-  - current directory when it already matches the supported Trine app target shape
-  - otherwise auto-detect a single supported Angular app target under the current directory
-  - when multiple supported app targets are found, re-run with --target <app-root>
+  - init is guided by default and asks for confirmation before mutating project files
+  - init --yes keeps a non-interactive fast path for automation and scripting
+  - current directory is used when it already matches the supported Trine app target shape
+  - otherwise init/add auto-detect a single supported Angular app target under the current directory
+  - when multiple supported app targets are found, guided init lets you choose and add still asks for --target
 
 Notes:
   - v0 supports init plus add button only
   - init owns target detection, framework detection, stylesheet resolution, baseline files, local @trine/ui alias setup, and local stylesheet wiring
-  - add button still works without init for backward compatibility, but init is now the preferred first step
+  - add button still works without init for backward compatibility, but init is the preferred first step
   - the current proven target model is Angular 21 + src/app + tsconfig.app.json + a global stylesheet entry such as src/styles.scss, src/styles.css, or src/global.scss resolved directly or from angular.json
   - v0 distinguishes angular and ionic-angular targets; unsupported frameworks fail clearly
   - the current proven styling/runtime baseline requires Tailwind CSS v4 and class-variance-authority in the target repo
@@ -26,13 +29,32 @@ Notes:
   - @trine/ui is configured as a consumer-local alias inside the target app
   - apps/demo keeps a temporary @trine/ui/* bridge for non-localized components during local repo verification`;
 const SUPPORTED_COMPONENTS = ['button'];
-function main(argv) {
+async function main(argv) {
     const [command, secondArg, ...rest] = argv;
     if (command === 'init') {
-        const selection = resolveTargetSelection(process.cwd(), argv.slice(1), 'trine init');
-        const result = initProject({
+        const flags = parseFlags(argv.slice(1), ['--target', '--yes']);
+        const selection = flags.yes
+            ? resolveNonInteractiveInitSelection(process.cwd(), flags.target)
+            : await resolveGuidedInitSelection(process.cwd(), flags.target);
+        const plan = planInitProject({
             target: selection.target,
             cwd: process.cwd(),
+            targetStylesEntry: selection.targetStylesEntry,
+        });
+        if (!hasInitMutations(plan)) {
+            printInitNoop(plan, selection);
+            return;
+        }
+        if (!flags.yes) {
+            printInitPreview(plan, selection);
+            const shouldProceed = await confirmAction('Proceed? (Y/n)');
+            if (!shouldProceed) {
+                console.log('trine init cancelled. No changes were made.');
+                return;
+            }
+        }
+        const result = applyInitPlan(plan, {
+            cwd: process.cwd(),
         });
         printInitSuccess(result, selection);
         return;
@@ -43,23 +65,54 @@ function main(argv) {
     if (!isSupportedComponent(secondArg)) {
         throw new Error(secondArg ? `Unsupported component: ${secondArg}\n\n${HELP_TEXT}` : HELP_TEXT);
     }
-    const selection = resolveTargetSelection(process.cwd(), rest, `trine add ${secondArg}`);
+    const flags = parseFlags(rest, ['--target']);
+    const selection = resolveTargetSelection(process.cwd(), flags.target, `trine add ${secondArg}`);
     const result = addButton({
         target: selection.target,
         cwd: process.cwd(),
     });
     printAddSuccess(secondArg, result, selection);
 }
-function readTarget(argv) {
+function resolveNonInteractiveInitSelection(cwd, explicitTarget) {
+    const selection = resolveTargetSelection(cwd, explicitTarget, 'trine init');
+    const targetRoot = path.resolve(cwd, selection.target);
+    const inspection = inspectProjectTarget(targetRoot);
+    if (inspection.framework !== 'unsupported' &&
+        inspection.targetStylesEntryCandidates.length > 1 &&
+        inspection.targetStylesEntryResolution === 'default') {
+        const displayTarget = selection.mode === 'cwd' ? '.' : toDisplayTarget(cwd, targetRoot);
+        throw new Error([
+            `Multiple plausible global stylesheet entries were found for target (${displayTarget}). Re-run without --yes to choose one interactively:`,
+            ...inspection.targetStylesEntryCandidates.map((candidate) => `- ${toDisplayFilePath(targetRoot, candidate)}`),
+        ].join('\n'));
+    }
+    return selection;
+}
+function parseFlags(argv, allowedFlags) {
+    const flags = {
+        yes: false,
+    };
     for (let index = 0; index < argv.length; index += 1) {
-        if (argv[index] === '--target') {
-            return argv[index + 1];
+        const token = argv[index];
+        if (!allowedFlags.includes(token)) {
+            throw new Error(`Unsupported flag: ${token}\n\n${HELP_TEXT}`);
+        }
+        if (token === '--yes') {
+            flags.yes = true;
+            continue;
+        }
+        if (token === '--target') {
+            const target = argv[index + 1];
+            if (!target || target.startsWith('--')) {
+                throw new Error(`--target requires a value.\n\n${HELP_TEXT}`);
+            }
+            flags.target = target;
+            index += 1;
         }
     }
-    return undefined;
+    return flags;
 }
-function resolveTargetSelection(cwd, argv, commandLabel) {
-    const explicitTarget = readTarget(argv);
+function resolveTargetSelection(cwd, explicitTarget, commandLabel) {
     if (explicitTarget) {
         return {
             target: explicitTarget,
@@ -90,6 +143,92 @@ function resolveTargetSelection(cwd, argv, commandLabel) {
         mode: 'cwd',
     };
 }
+async function resolveGuidedInitSelection(cwd, explicitTarget) {
+    const targetSelection = explicitTarget
+        ? {
+            target: explicitTarget,
+            mode: 'explicit',
+        }
+        : await chooseInitTarget(cwd);
+    const targetRoot = path.resolve(cwd, targetSelection.target);
+    const inspection = inspectProjectTarget(targetRoot);
+    if (inspection.framework === 'unsupported') {
+        return targetSelection;
+    }
+    if (inspection.targetStylesEntryCandidates.length > 1 &&
+        inspection.targetStylesEntryResolution === 'default') {
+        const targetStylesEntry = await chooseFromList('Multiple plausible global stylesheet entries were found:', inspection.targetStylesEntryCandidates, {
+            renderItem: (item, index) => `${String(index + 1)}. ${toDisplayFilePath(targetRoot, item)}`,
+        });
+        return {
+            ...targetSelection,
+            targetStylesEntry,
+        };
+    }
+    return targetSelection;
+}
+async function chooseInitTarget(cwd) {
+    if (looksLikeAngularAppRoot(cwd)) {
+        return {
+            target: '.',
+            mode: 'cwd',
+        };
+    }
+    const matches = findAngularAppTargets(cwd);
+    if (matches.length === 1) {
+        return {
+            target: matches[0],
+            mode: 'auto-detected',
+        };
+    }
+    if (matches.length > 1) {
+        const selected = await chooseFromList('Multiple supported apps found:', matches);
+        return {
+            target: selected,
+            mode: 'selected',
+        };
+    }
+    return {
+        target: '.',
+        mode: 'cwd',
+    };
+}
+function printInitPreview(plan, selection) {
+    const displayTarget = toDisplayTarget(process.cwd(), plan.targetRoot);
+    const stylesheetDisplay = toDisplayFilePath(plan.targetRoot, plan.targetStylesEntry);
+    const lines = [
+        `Detected target: ${displayTarget}`,
+        `Detected framework: ${plan.framework}`,
+        `Detected stylesheet entry: ${stylesheetDisplay}`,
+    ];
+    if (selection.mode === 'auto-detected' || selection.mode === 'selected') {
+        lines.push(`Selected app: ${displayTarget}`);
+    }
+    lines.push('', 'Trine will:', ...renderPlannedInitActions(plan));
+    if (plan.warnings.length > 0) {
+        lines.push('', 'Warnings:', ...plan.warnings.map((warning) => `- ${warning}`));
+    }
+    console.log(lines.join('\n'));
+}
+function printInitNoop(plan, selection) {
+    const displayTarget = toDisplayTarget(process.cwd(), plan.targetRoot);
+    const stylesheetDisplay = toDisplayFilePath(plan.targetRoot, plan.targetStylesEntry);
+    const lines = [
+        'trine init found the Trine baseline already in place.',
+        `Target: ${displayTarget}`,
+        `Framework: ${plan.framework}`,
+        `Resolved stylesheet entry: ${stylesheetDisplay}`,
+    ];
+    if (selection.mode === 'auto-detected' || selection.mode === 'selected') {
+        lines.push(`Selected app: ${displayTarget}`);
+    }
+    lines.push('', 'Already in place:', ...renderFileGroup(plan.reusedFiles, '- nothing to report'));
+    if (plan.warnings.length > 0) {
+        lines.push('', 'Warnings:', ...plan.warnings.map((warning) => `- ${warning}`));
+    }
+    lines.push('', 'No changes were made.');
+    console.log(lines.join('\n'));
+}
 function printInitSuccess(result, selection) {
     const displayTarget = toDisplayTarget(process.cwd(), result.targetRoot);
     const stylesheetDisplay = toDisplayFilePath(result.targetRoot, result.targetStylesEntry);
@@ -99,7 +238,7 @@ function printInitSuccess(result, selection) {
         `Framework: ${result.framework}`,
         `Resolved stylesheet entry: ${stylesheetDisplay}`,
     ];
-    if (selection.mode === 'auto-detected') {
+    if (selection.mode === 'auto-detected' || selection.mode === 'selected') {
         lines.push(`Selected app: ${displayTarget}`);
     }
     lines.push('', 'Created:', ...renderFileGroup(result.createdFiles, '- nothing created'), '', 'Reused:', ...renderFileGroup(result.reusedFiles, '- nothing reused'), '', 'Updated:', ...renderFileGroup(result.updatedFiles, '- nothing updated'));
@@ -130,6 +269,16 @@ function printAddSuccess(component, result, selection) {
 function renderFileGroup(files, emptyMessage) {
     return files.length > 0 ? files.map((file) => `- ${file}`) : [emptyMessage];
 }
+function renderPlannedInitActions(plan) {
+    return [
+        ...plan.createdFiles.map((file) => `- create ${file}`),
+        ...plan.updatedFiles.map((file) => `- update ${file}`),
+        ...plan.reusedFiles.map((file) => `- keep ${file}`),
+    ];
+}
+function hasInitMutations(plan) {
+    return plan.createdFiles.length > 0 || plan.updatedFiles.length > 0;
+}
 function isSupportedComponent(value) {
     return SUPPORTED_COMPONENTS.some((component) => component === value);
 }
@@ -143,11 +292,8 @@ function toDisplayTarget(cwd, targetRoot) {
 function toDisplayFilePath(targetRoot, filePath) {
     return path.relative(targetRoot, filePath) || '.';
 }
-try {
-    main(process.argv.slice(2));
-}
-catch (error) {
+await main(process.argv.slice(2)).catch((error) => {
     const message = error instanceof Error ? error.message : String(error);
     console.error(message);
     process.exitCode = 1;
-}
+});

package/dist/init.js

@@ -1,17 +1,19 @@
 import path from 'node:path';
-import { ensureSharedStyleBaseline, ensureStylesImport, ensureTsconfigAlias, ensureUiRootBarrel, isDemoTarget, readTargetDependencyWarnings, resolveSupportedProjectTarget, toTargetRelativePath, } from "./project.js";
-export function initProject(options) {
+import { ensureSharedStyleBaseline, ensureStylesImport, ensureTsconfigAlias, ensureUiRootBarrel, inspectSharedStyleBaseline, inspectStylesImport, inspectTsconfigAlias, inspectUiRootBarrel, isDemoTarget, readTargetDependencyWarnings, resolveSupportedProjectTarget, toTargetRelativePath, } from "./project.js";
+export function planInitProject(options) {
     const targetRoot = path.resolve(options.cwd, options.target);
-    const { framework, targetStylesEntry, targetTsconfig } = resolveSupportedProjectTarget('trine init', targetRoot);
+    const { framework, targetStylesEntry, targetTsconfig } = resolveSupportedProjectTarget('trine init', targetRoot, {
+        preferredStylesEntry: options.targetStylesEntry,
+    });
     const createdFiles = [];
     const updatedFiles = [];
     const reusedFiles = [];
     const warnings = [];
-    const sharedStylesResult = ensureSharedStyleBaseline(targetRoot, 'Trine components');
+    const sharedStylesResult = inspectSharedStyleBaseline(targetRoot, 'Trine components');
     createdFiles.push(...sharedStylesResult.createdFiles);
     reusedFiles.push(...sharedStylesResult.reusedFiles);
     warnings.push(...sharedStylesResult.warnings);
-    const uiRootResult = ensureUiRootBarrel(targetRoot);
+    const uiRootResult = inspectUiRootBarrel(targetRoot);
     if (uiRootResult.created) {
         createdFiles.push(uiRootResult.file);
     }
@@ -19,15 +21,15 @@ export function initProject(options) {
         reusedFiles.push(uiRootResult.file);
     }
     const tsconfigDisplayPath = toTargetRelativePath(targetRoot, targetTsconfig);
-    if (ensureTsconfigAlias(targetTsconfig, targetRoot, options.cwd)) {
+    if (inspectTsconfigAlias(targetTsconfig, targetRoot, options.cwd).needsUpdate) {
         updatedFiles.push(tsconfigDisplayPath);
     }
     else {
         reusedFiles.push(tsconfigDisplayPath);
     }
     const stylesDisplayPath = toTargetRelativePath(targetRoot, targetStylesEntry);
-    const stylesResult = ensureStylesImport(targetStylesEntry);
-    if (stylesResult.updated) {
+    const stylesResult = inspectStylesImport(targetStylesEntry);
+    if (stylesResult.needsUpdate) {
         updatedFiles.push(stylesDisplayPath);
     }
     else {
@@ -44,6 +46,7 @@ export function initProject(options) {
     }
     return {
         targetRoot,
+        targetTsconfig,
         framework,
         targetStylesEntry,
         createdFiles,
@@ -52,3 +55,15 @@ export function initProject(options) {
         warnings,
     };
 }
+export function applyInitPlan(plan, options) {
+    ensureSharedStyleBaseline(plan.targetRoot, 'Trine components');
+    ensureUiRootBarrel(plan.targetRoot);
+    ensureTsconfigAlias(plan.targetTsconfig, plan.targetRoot, options.cwd);
+    ensureStylesImport(plan.targetStylesEntry);
+    return plan;
+}
+export function initProject(options) {
+    return applyInitPlan(planInitProject(options), {
+        cwd: options.cwd,
+    });
+}

package/dist/project.js

@@ -8,10 +8,11 @@ const CONVENTIONAL_STYLE_ENTRY_PATHS = ['src/styles.scss', 'src/styles.css', 'sr
 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 +31,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.`,
@@ -60,17 +63,31 @@ export function looksLikeAngularAppRoot(root) {
     return inspectProjectTarget(root).framework !== 'unsupported';
 }
 export function ensureSharedStyleBaseline(targetRoot, componentLabel) {
+    const inspection = inspectSharedStyleBaseline(targetRoot, componentLabel);
+    const stylesDestDir = path.join(targetRoot, 'src', 'styles');
+    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));
+        if (!inspection.createdFiles.includes(toTargetRelativePath(targetRoot, destinationPath))) {
+            continue;
+        }
+        if (!existsSync(destinationPath)) {
+            copyFileSync(templatePath, destinationPath);
+        }
+    }
+    return inspection;
+}
+export function inspectSharedStyleBaseline(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;
         }
@@ -88,16 +105,18 @@ export function ensureSharedStyleBaseline(targetRoot, componentLabel) {
 }
 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 +141,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 +153,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,14 +164,41 @@ export function ensureTsconfigAlias(tsconfigPath, targetRoot, cwd) {
     writeFileSync(tsconfigPath, `${JSON.stringify(config, null, 2)}\n`);
     return true;
 }
+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);
+    if (aliasIsCurrent && wildcardIsCurrent) {
+        return {
+            needsUpdate: false,
+        };
+    }
+    return {
+        needsUpdate: true,
+    };
+}
 export function ensureStylesImport(stylesPath) {
-    const current = readFileSync(stylesPath, 'utf8');
-    if (current.includes(STYLE_IMPORT_LINE)) {
+    const inspection = inspectStylesImport(stylesPath);
+    if (!inspection.needsUpdate) {
         return {
             updated: false,
-            authoringImportStillPresent: current.includes("@import '@trine/ui/styles/trine.css';"),
+            authoringImportStillPresent: inspection.authoringImportStillPresent,
         };
     }
+    const current = readFileSync(stylesPath, 'utf8');
     const lines = current.split('\n');
     let insertAt = -1;
     for (let index = 0; index < lines.length; index += 1) {
@@ -179,6 +216,13 @@ export function ensureStylesImport(stylesPath) {
     writeFileSync(stylesPath, lines.join('\n'));
     return {
         updated: true,
+        authoringImportStillPresent: inspection.authoringImportStillPresent,
+    };
+}
+export function inspectStylesImport(stylesPath) {
+    const current = readFileSync(stylesPath, 'utf8');
+    return {
+        needsUpdate: !current.includes(STYLE_IMPORT_LINE),
         authoringImportStillPresent: current.includes("@import '@trine/ui/styles/trine.css';"),
     };
 }
@@ -215,20 +259,23 @@ export function readTargetDependencyWarnings(targetRoot, 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 +334,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 +345,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 +355,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);
@@ -359,3 +407,48 @@ 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 trineOwnedCandidates = candidates.filter((candidate) => {
+        try {
+            return readFileSync(candidate, 'utf8').includes(STYLE_IMPORT_LINE);
+        }
+        catch {
+            return false;
+        }
+    });
+    if (trineOwnedCandidates.length === 1) {
+        return {
+            targetStylesEntry: trineOwnedCandidates[0],
+            targetStylesEntryResolution: 'trine-import',
+        };
+    }
+    if (candidates.length > 0) {
+        return {
+            targetStylesEntry: candidates[0],
+            targetStylesEntryResolution: 'default',
+        };
+    }
+    return {
+        targetStylesEntry: undefined,
+        targetStylesEntryResolution: 'none',
+    };
+}

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.3.0",
   "type": "module",
   "description": "Copy-paste ownership CLI for Trine UI components.",
   "main": "./dist/index.js",