@trineui/cli 0.1.2 → 0.3.0

package/README.md

@@ -6,25 +6,42 @@ Canonical public package:
 npx @trineui/cli@latest add button
 ```
 
-Current v0 command:
+Registry status note:
+
+- live npm `@latest` is currently `0.1.2`
+- repo-local next publish candidate is `0.2.0`
+- the live registry package currently exposes `add button`
+- `init` is implemented in this repo and included in the next publish candidate, but it is not available from the live npm package until publish succeeds
+
+Repository-local current command surface:
 
 ```bash
+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`
 - the CLI command exposed through the package bin is still `trine`
 - `apps/consumer-fixture` is the first separate-target proof and does not use the demo-only `@trine/ui/*` bridge
 - `/tmp/trine-button-publish-proof` is the latest truly external packaged-proof repo outside the monorepo
 - 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`
@@ -38,5 +55,6 @@ Notes:
 Local package proof equivalent:
 
 ```bash
-npx --yes --package /absolute/path/to/trineui-cli-0.1.0.tgz trine add button
+npx --yes --package /absolute/path/to/trineui-cli-<version>.tgz trine init
+npx --yes --package /absolute/path/to/trineui-cli-<version>.tgz trine add button
 ```

package/dist/add-component.js

@@ -1,11 +1,6 @@
 import { copyFileSync, existsSync, mkdirSync, 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 TEMPLATE_ROOT = fileURLToPath(new URL('../templates/', import.meta.url));
-const LOCAL_REPO_DEMO_ROOT = path.resolve(TEMPLATE_ROOT, '../../../apps/demo');
-const STYLE_IMPORT_LINE = "@import './styles/trine-consumer.css';";
+import { TEMPLATE_ROOT, ensureLinesFile, ensureSharedStyleBaseline, ensureStylesImport, ensureTsconfigAlias, isDemoTarget, readTargetDependencyWarnings, resolveSupportedProjectTarget, toTargetRelativePath, } from "./project.js";
 const DEMO_BRIDGE_COMMENT = '// Temporary demo verification bridge: delivered local components resolve locally; other components still re-export from the authoring source.';
 const DEMO_LOCAL_COMPONENTS = [
     {
@@ -61,9 +56,8 @@ const DEMO_PROXY_EXPORT_LINES = [
 ];
 export function addComponent(manifest, options) {
     const targetRoot = path.resolve(options.cwd, options.target);
-    const { targetStylesEntry, targetTsconfig } = resolveTargetShape(manifest.componentName, targetRoot);
+    const { targetStylesEntry, targetTsconfig } = resolveSupportedProjectTarget(`trine add ${manifest.componentName}`, targetRoot);
     const componentDestDir = path.join(targetRoot, 'src', 'app', 'components', 'ui', manifest.componentName);
-    const stylesDestDir = path.join(targetRoot, 'src', 'styles');
     const componentCopyTargets = manifest.sourceFiles.map((source) => ({
         source: path.join(TEMPLATE_ROOT, source),
         destination: path.join(componentDestDir, path.basename(source)),
@@ -78,13 +72,12 @@ export function addComponent(manifest, options) {
         ].join('\n'));
     }
     mkdirSync(componentDestDir, { recursive: true });
-    mkdirSync(stylesDestDir, { recursive: true });
     for (const { source, destination } of componentCopyTargets) {
         copyFileSync(source, destination);
     }
     const componentCopiedFiles = componentCopyTargets.map(({ destination }) => toTargetRelativePath(targetRoot, destination));
-    const sharedStylesResult = ensureSharedStyleBaseline(targetRoot, stylesDestDir, manifest.componentLabel);
-    const copiedFiles = [...componentCopiedFiles, ...sharedStylesResult.copiedFiles];
+    const sharedStylesResult = ensureSharedStyleBaseline(targetRoot, manifest.componentLabel);
+    const copiedFiles = [...componentCopiedFiles, ...sharedStylesResult.createdFiles];
     const updatedFiles = [];
     const warnings = [...sharedStylesResult.warnings];
     const componentBarrelPath = path.join(componentDestDir, 'index.ts');
@@ -122,78 +115,6 @@ export function addComponent(manifest, options) {
         targetRoot,
     };
 }
-function ensureSharedStyleBaseline(targetRoot, stylesDestDir, componentLabel) {
-    const copiedFiles = [];
-    const warnings = [];
-    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);
-            copiedFiles.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.`);
-        }
-    }
-    return {
-        copiedFiles,
-        warnings,
-    };
-}
-function resolveTargetShape(componentName, targetRoot) {
-    const targetAppDir = path.join(targetRoot, 'src', 'app');
-    const targetTsconfig = path.join(targetRoot, 'tsconfig.app.json');
-    const targetStylesEntry = resolveStylesEntry(targetRoot);
-    const missing = [];
-    if (!existsSync(targetRoot)) {
-        missing.push(targetRoot);
-    }
-    if (!existsSync(targetAppDir)) {
-        missing.push(targetAppDir);
-    }
-    if (!targetStylesEntry) {
-        missing.push(`${path.join(targetRoot, 'src', 'styles.scss')} or ${path.join(targetRoot, 'src', 'styles.css')} or the first resolvable build styles entry in ${path.join(targetRoot, 'angular.json')}`);
-    }
-    if (!existsSync(targetTsconfig)) {
-        missing.push(targetTsconfig);
-    }
-    if (missing.length > 0) {
-        throw new Error([
-            `trine add ${componentName} requires an Angular app target with src/app, a global stylesheet entry, and tsconfig.app.json.`,
-            ...missing.map((file) => `- ${file}`),
-        ].join('\n'));
-    }
-    if (!targetStylesEntry) {
-        throw new Error(`trine add ${componentName} could not resolve a global stylesheet entry for ${targetRoot}.`);
-    }
-    return {
-        targetStylesEntry,
-        targetTsconfig,
-    };
-}
-function ensureLinesFile(filePath, lines) {
-    const existing = existsSync(filePath) ? readFileSync(filePath, 'utf8') : '';
-    const normalizedExisting = existing.trimEnd();
-    const currentLines = normalizedExisting === '' ? [] : normalizedExisting.split('\n');
-    let changed = false;
-    for (const line of lines) {
-        if (!currentLines.includes(line)) {
-            currentLines.push(line);
-            changed = true;
-        }
-    }
-    if (!existsSync(filePath)) {
-        changed = true;
-    }
-    if (changed) {
-        mkdirSync(path.dirname(filePath), { recursive: true });
-        writeFileSync(filePath, `${currentLines.join('\n')}\n`);
-    }
-    return changed;
-}
 function rewriteDemoUiRootBarrel(filePath) {
     const uiRootDir = path.dirname(filePath);
     const localComponentLines = DEMO_LOCAL_COMPONENTS.filter(({ key }) => existsSync(path.join(uiRootDir, key, 'index.ts')));
@@ -212,151 +133,3 @@ function rewriteDemoUiRootBarrel(filePath) {
     writeFileSync(filePath, nextContent);
     return true;
 }
-function ensureTsconfigAlias(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 = isDemoTarget(targetRoot)
-        ? toPosixPath(path.relative(process.cwd(), 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;
-    }
-    config.compilerOptions.paths['@trine/ui'] = [aliasTarget];
-    if (isDemoTarget(targetRoot)) {
-        config.compilerOptions.paths['@trine/ui/*'] = [wildcardTarget];
-    }
-    else if ('@trine/ui/*' in config.compilerOptions.paths) {
-        delete config.compilerOptions.paths['@trine/ui/*'];
-    }
-    writeFileSync(tsconfigPath, `${JSON.stringify(config, null, 2)}\n`);
-    return true;
-}
-function ensureStylesImport(stylesPath) {
-    const current = readFileSync(stylesPath, 'utf8');
-    if (current.includes(STYLE_IMPORT_LINE)) {
-        return {
-            updated: false,
-            authoringImportStillPresent: current.includes("@import '@trine/ui/styles/trine.css';"),
-        };
-    }
-    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'));
-    return {
-        updated: true,
-        authoringImportStillPresent: current.includes("@import '@trine/ui/styles/trine.css';"),
-    };
-}
-function isDemoTarget(targetRoot) {
-    return (existsSync(LOCAL_REPO_DEMO_ROOT) &&
-        path.resolve(targetRoot) === path.resolve(LOCAL_REPO_DEMO_ROOT));
-}
-function toPosixPath(filePath) {
-    return filePath.split(path.sep).join(path.posix.sep);
-}
-function toConfigRelativePath(filePath) {
-    const posixPath = toPosixPath(filePath);
-    return posixPath.startsWith('.') ? posixPath : `./${posixPath}`;
-}
-function toTargetRelativePath(targetRoot, filePath) {
-    return toPosixPath(path.relative(targetRoot, filePath));
-}
-function readTargetDependencyWarnings(targetRoot, componentLabel) {
-    const packageJsonPath = path.join(targetRoot, 'package.json');
-    if (!existsSync(packageJsonPath)) {
-        return [
-            'No package.json was found in the target root, so Tailwind CSS v4 and class-variance-authority prerequisites could not be checked automatically.',
-        ];
-    }
-    try {
-        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-        const deps = {
-            ...(packageJson.dependencies ?? {}),
-            ...(packageJson.devDependencies ?? {}),
-        };
-        const warnings = [];
-        if (!deps['class-variance-authority']) {
-            warnings.push(`class-variance-authority is missing from the target repo. Install it before building the delivered ${componentLabel}.`);
-        }
-        const tailwindRange = deps['tailwindcss'];
-        if (!tailwindRange) {
-            warnings.push(`tailwindcss is missing from the target repo. The current proven ${componentLabel} baseline expects Tailwind CSS v4.`);
-        }
-        else if (!looksLikeTailwindV4(tailwindRange)) {
-            warnings.push(`The target repo declares tailwindcss@${tailwindRange}. The current proven ${componentLabel} baseline expects Tailwind CSS v4.`);
-        }
-        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}.`,
-        ];
-    }
-}
-function looksLikeTailwindV4(range) {
-    return /(^|[^\d])4(\D|$)/.test(range);
-}
-export function looksLikeAngularAppRoot(root) {
-    return (existsSync(path.join(root, 'src', 'app')) &&
-        existsSync(path.join(root, 'tsconfig.app.json')) &&
-        resolveStylesEntry(root) !== undefined);
-}
-function resolveStylesEntry(targetRoot) {
-    const conventionalStyles = ['src/styles.scss', 'src/styles.css'];
-    for (const relativePath of conventionalStyles) {
-        const absolutePath = path.join(targetRoot, relativePath);
-        if (existsSync(absolutePath)) {
-            return absolutePath;
-        }
-    }
-    const angularJsonPath = path.join(targetRoot, 'angular.json');
-    if (!existsSync(angularJsonPath)) {
-        return undefined;
-    }
-    try {
-        const angularJson = JSON.parse(readFileSync(angularJsonPath, 'utf8'));
-        for (const project of Object.values(angularJson.projects ?? {})) {
-            const styles = project.architect?.build?.options?.styles ?? project.targets?.build?.options?.styles ?? [];
-            for (const styleEntry of styles) {
-                const relativePath = typeof styleEntry === 'string' ? styleEntry : (styleEntry.input ?? undefined);
-                if (!relativePath) {
-                    continue;
-                }
-                const absolutePath = path.join(targetRoot, relativePath);
-                if (existsSync(absolutePath)) {
-                    return absolutePath;
-                }
-            }
-        }
-    }
-    catch {
-        return undefined;
-    }
-    return undefined;
-}

package/dist/index.js

@@ -1,133 +1,299 @@
 #!/usr/bin/env node
-import { readdirSync } from 'node:fs';
 import path from 'node:path';
-import { looksLikeAngularAppRoot } from "./add-component.js";
 import { addButton } from "./add-button.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>] [--yes]
   npx @trineui/cli@latest add button [--target <app-root>]
+  trine init [--target <app-root>] [--yes]
   trine add button [--target <app-root>]
 
 Defaults:
-  - current directory when it matches the supported Angular app target shape
-  - otherwise auto-detect a single Angular app target under the current directory
-  - when multiple Angular 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 Button only
-  - external targets can run trine add button from the app root or pass --target /absolute/path/to/angular-app
-  - 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 from angular.json
-  - use a Node LTS line supported by Angular 21 in the target repo
+  - 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 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
   - consumer-owned component files fail clearly if they already exist
   - shared styling baseline files are copied when missing and preserved when they already exist
   - @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) {
-    const [command, component, ...rest] = argv;
+async function main(argv) {
+    const [command, secondArg, ...rest] = argv;
+    if (command === 'init') {
+        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;
+    }
     if (command !== 'add') {
         throw new Error(command ? `Unsupported command: ${command}\n\n${HELP_TEXT}` : HELP_TEXT);
     }
-    if (!isSupportedComponent(component)) {
-        throw new Error(component ? `Unsupported component: ${component}\n\n${HELP_TEXT}` : HELP_TEXT);
+    if (!isSupportedComponent(secondArg)) {
+        throw new Error(secondArg ? `Unsupported component: ${secondArg}\n\n${HELP_TEXT}` : HELP_TEXT);
     }
-    const target = readTarget(rest) ?? autoDetectTarget(process.cwd());
+    const flags = parseFlags(rest, ['--target']);
+    const selection = resolveTargetSelection(process.cwd(), flags.target, `trine add ${secondArg}`);
     const result = addButton({
-        target,
+        target: selection.target,
         cwd: process.cwd(),
     });
-    printSuccess('button', result);
+    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 printSuccess(component, result) {
-    const relativeTarget = path.relative(process.cwd(), result.targetRoot) || '.';
-    const displayTarget = relativeTarget.startsWith('..') ? result.targetRoot : relativeTarget;
-    const componentLabel = capitalize(component);
-    const isRepoDemoVerification = result.warnings.some((warning) => warning.includes('temporary @trine/ui/* bridge'));
+function resolveTargetSelection(cwd, explicitTarget, commandLabel) {
+    if (explicitTarget) {
+        return {
+            target: explicitTarget,
+            mode: 'explicit',
+        };
+    }
+    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) {
+        throw new Error([
+            `Multiple supported Angular app targets were found under the current directory. Re-run with ${commandLabel} --target <app-root>:`,
+            ...matches.map((match) => `- ${match}`),
+        ].join('\n'));
+    }
+    return {
+        target: '.',
+        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 add ${component} completed.`,
+        'trine init found the Trine baseline already in place.',
         `Target: ${displayTarget}`,
-        '',
-        'Copied files:',
-        ...result.copiedFiles.map((file) => `- ${file}`),
-        '',
-        'Created or updated:',
-        ...result.updatedFiles.map((file) => `- ${file}`),
+        `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);
+    const lines = [
+        'trine init completed.',
+        `Target: ${displayTarget}`,
+        `Framework: ${result.framework}`,
+        `Resolved stylesheet entry: ${stylesheetDisplay}`,
+    ];
+    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'));
+    if (result.warnings.length > 0) {
+        lines.push('', 'Warnings:', ...result.warnings.map((warning) => `- ${warning}`));
+    }
+    lines.push('', 'Manual next steps:', '- Review prerequisite warnings and install anything still missing before building the target app.', '- Run trine add button when you want to deliver the first Trine component into this project.', '- Build the target app and confirm @trine/ui resolves through the local consumer-owned source tree.');
+    console.log(lines.join('\n'));
+}
+function printAddSuccess(component, result, selection) {
+    const displayTarget = toDisplayTarget(process.cwd(), result.targetRoot);
+    const componentLabel = capitalize(component);
+    const isRepoDemoVerification = result.warnings.some((warning) => warning.includes('temporary @trine/ui/* bridge'));
+    const lines = [`trine add ${component} completed.`, `Target: ${displayTarget}`];
+    if (selection.mode === 'auto-detected') {
+        lines.push(`Selected app: ${displayTarget}`);
+    }
+    lines.push('', 'Copied files:', ...renderFileGroup(result.copiedFiles, '- nothing copied'), '', 'Created or updated:', ...renderFileGroup(result.updatedFiles, '- nothing created or updated'));
     if (result.warnings.length > 0) {
         lines.push('', 'Warnings:', ...result.warnings.map((warning) => `- ${warning}`));
     }
-    lines.push('', 'Manual next steps:', `- Ensure the target repo has Tailwind CSS v4 and class-variance-authority installed before building the delivered ${componentLabel}.`, `- Build the target app and confirm ${componentLabel} imports resolve through the local @trine/ui alias.`, `- Review the copied ${component}.skin.ts and tokens.css if you want local consumer customization.`);
+    lines.push('', 'Manual next steps:', `- Ensure the target repo has Tailwind CSS v4 and class-variance-authority installed before building the delivered ${componentLabel}.`, `- Build the target app and confirm ${componentLabel} imports resolve through the local @trine/ui alias.`, `- Review the copied ${component}.skin.ts and tokens.css if you want local consumer customization.`, '- For future setup in this repo, prefer running trine init first so project-level Trine baseline files are already in place.');
     if (isRepoDemoVerification) {
         lines.push('- Open /validation-shell and review the CLI delivery proof section for the temporary demo verification path.');
     }
     console.log(lines.join('\n'));
 }
+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);
 }
 function capitalize(value) {
     return value.charAt(0).toUpperCase() + value.slice(1);
 }
-function autoDetectTarget(cwd) {
-    if (looksLikeAngularAppRoot(cwd)) {
-        return '.';
-    }
-    const matches = findAngularAppTargets(cwd);
-    if (matches.length === 1) {
-        return matches[0];
-    }
-    if (matches.length > 1) {
-        throw new Error([
-            'Multiple Angular app targets were found under the current directory. Re-run with --target <app-root>:',
-            ...matches.map((match) => `- ${match}`),
-        ].join('\n'));
-    }
-    return '.';
+function toDisplayTarget(cwd, targetRoot) {
+    const relativeTarget = path.relative(cwd, targetRoot) || '.';
+    return relativeTarget.startsWith('..') ? targetRoot : relativeTarget;
 }
-function findAngularAppTargets(root) {
-    const matches = new Set();
-    walkForAngularApps(root, root, matches);
-    return [...matches].sort((left, right) => left.localeCompare(right));
+function toDisplayFilePath(targetRoot, filePath) {
+    return path.relative(targetRoot, filePath) || '.';
 }
-function walkForAngularApps(root, currentDir, matches) {
-    for (const entry of readdirSync(currentDir, { withFileTypes: true })) {
-        if (entry.isDirectory()) {
-            if (shouldSkipDirectory(entry.name)) {
-                continue;
-            }
-            walkForAngularApps(root, path.join(currentDir, entry.name), matches);
-            continue;
-        }
-        if (!entry.isFile() || entry.name !== 'tsconfig.app.json') {
-            continue;
-        }
-        const candidateRoot = currentDir;
-        if (!looksLikeAngularAppRoot(candidateRoot)) {
-            continue;
-        }
-        const relativeRoot = path.relative(root, candidateRoot) || '.';
-        matches.add(toPosixPath(relativeRoot));
-    }
-}
-function shouldSkipDirectory(name) {
-    return ['.angular', '.git', '.playwright-cli', 'dist', 'node_modules', 'output'].includes(name);
-}
-function toPosixPath(filePath) {
-    return filePath.split(path.sep).join(path.posix.sep);
-}
-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

@@ -0,0 +1,69 @@
+import path from 'node:path';
+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, {
+        preferredStylesEntry: options.targetStylesEntry,
+    });
+    const createdFiles = [];
+    const updatedFiles = [];
+    const reusedFiles = [];
+    const warnings = [];
+    const sharedStylesResult = inspectSharedStyleBaseline(targetRoot, 'Trine components');
+    createdFiles.push(...sharedStylesResult.createdFiles);
+    reusedFiles.push(...sharedStylesResult.reusedFiles);
+    warnings.push(...sharedStylesResult.warnings);
+    const uiRootResult = inspectUiRootBarrel(targetRoot);
+    if (uiRootResult.created) {
+        createdFiles.push(uiRootResult.file);
+    }
+    else {
+        reusedFiles.push(uiRootResult.file);
+    }
+    const tsconfigDisplayPath = toTargetRelativePath(targetRoot, targetTsconfig);
+    if (inspectTsconfigAlias(targetTsconfig, targetRoot, options.cwd).needsUpdate) {
+        updatedFiles.push(tsconfigDisplayPath);
+    }
+    else {
+        reusedFiles.push(tsconfigDisplayPath);
+    }
+    const stylesDisplayPath = toTargetRelativePath(targetRoot, targetStylesEntry);
+    const stylesResult = inspectStylesImport(targetStylesEntry);
+    if (stylesResult.needsUpdate) {
+        updatedFiles.push(stylesDisplayPath);
+    }
+    else {
+        reusedFiles.push(stylesDisplayPath);
+    }
+    if (stylesResult.authoringImportStillPresent) {
+        warnings.push(`${stylesDisplayPath} still imports @trine/ui/styles/trine.css for a broader authoring baseline outside the local Trine consumer setup.`);
+    }
+    if (isDemoTarget(targetRoot)) {
+        warnings.push('apps/demo keeps a temporary @trine/ui/* bridge for non-localized components so the internal demo app can still build while local Trine source is verified.');
+    }
+    else {
+        warnings.push(...readTargetDependencyWarnings(targetRoot, 'Trine components'));
+    }
+    return {
+        targetRoot,
+        targetTsconfig,
+        framework,
+        targetStylesEntry,
+        createdFiles,
+        updatedFiles,
+        reusedFiles,
+        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

@@ -0,0 +1,454 @@
+import { copyFileSync, 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 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, options = {}) {
+    const targetAppDir = path.join(targetRoot, 'src', 'app');
+    const targetTsconfig = path.join(targetRoot, 'tsconfig.app.json');
+    const targetStylesEntryCandidates = resolveStylesEntryCandidates(targetRoot);
+    const { targetStylesEntry, targetStylesEntryResolution } = resolveStylesEntrySelection(targetRoot, targetStylesEntryCandidates, options.preferredStylesEntry);
+    const missingPaths = [];
+    if (!existsSync(targetRoot)) {
+        missingPaths.push(targetRoot);
+    }
+    if (!existsSync(targetAppDir)) {
+        missingPaths.push(targetAppDir);
+    }
+    if (!targetStylesEntry) {
+        missingPaths.push(`${path.join(targetRoot, 'src', 'styles.scss')} or ${path.join(targetRoot, 'src', 'styles.css')} or ${path.join(targetRoot, 'src', 'global.scss')} or the first resolvable build styles entry in ${findNearestAngularJsonDisplayPath(targetRoot)}`);
+    }
+    if (!existsSync(targetTsconfig)) {
+        missingPaths.push(targetTsconfig);
+    }
+    const framework = missingPaths.length === 0 ? detectProjectFramework(targetRoot) : 'unsupported';
+    return {
+        targetRoot,
+        targetAppDir,
+        targetTsconfig,
+        targetStylesEntryCandidates,
+        targetStylesEntry,
+        targetStylesEntryResolution,
+        framework,
+        missingPaths,
+    };
+}
+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.`,
+            ...inspection.missingPaths.map((file) => `- ${file}`),
+        ].join('\n'));
+    }
+    return {
+        targetRoot: inspection.targetRoot,
+        targetAppDir: inspection.targetAppDir,
+        targetTsconfig: inspection.targetTsconfig,
+        targetStylesEntry: inspection.targetStylesEntry,
+        framework: inspection.framework,
+    };
+}
+export function findAngularAppTargets(root) {
+    const matches = new Set();
+    walkForAngularApps(root, root, matches);
+    return [...matches].sort((left, right) => left.localeCompare(right));
+}
+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 = [];
+    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)) {
+            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');
+    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: !existsSync(uiRootPath),
+        file: toTargetRelativePath(targetRoot, uiRootPath),
+    };
+}
+export function ensureLinesFile(filePath, lines) {
+    const existing = existsSync(filePath) ? readFileSync(filePath, 'utf8') : '';
+    const normalizedExisting = existing.trimEnd();
+    const currentLines = normalizedExisting === '' ? [] : normalizedExisting.split('\n');
+    let changed = false;
+    for (const line of lines) {
+        if (!currentLines.includes(line)) {
+            currentLines.push(line);
+            changed = true;
+        }
+    }
+    if (!existsSync(filePath)) {
+        changed = true;
+    }
+    if (changed) {
+        mkdirSync(path.dirname(filePath), { recursive: true });
+        writeFileSync(filePath, `${currentLines.join('\n')}\n`);
+    }
+    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) {
+        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);
+    config.compilerOptions.paths['@trine/ui'] = [aliasTarget];
+    if (isDemoTarget(targetRoot)) {
+        config.compilerOptions.paths['@trine/ui/*'] = [wildcardTarget];
+    }
+    else if ('@trine/ui/*' in config.compilerOptions.paths) {
+        delete config.compilerOptions.paths['@trine/ui/*'];
+    }
+    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 inspection = inspectStylesImport(stylesPath);
+    if (!inspection.needsUpdate) {
+        return {
+            updated: false,
+            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) {
+        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'));
+    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';"),
+    };
+}
+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.',
+        ];
+    }
+    try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        const deps = {
+            ...(packageJson.dependencies ?? {}),
+            ...(packageJson.devDependencies ?? {}),
+        };
+        const warnings = [];
+        if (!deps['class-variance-authority']) {
+            warnings.push(`class-variance-authority is missing from the target repo. Install it before building the delivered ${componentLabel}.`);
+        }
+        const tailwindRange = deps['tailwindcss'];
+        if (!tailwindRange) {
+            warnings.push(`tailwindcss is missing from the target repo. The current proven ${componentLabel} baseline expects Tailwind CSS v4.`);
+        }
+        else if (!looksLikeTailwindV4(tailwindRange)) {
+            warnings.push(`The target repo declares tailwindcss@${tailwindRange}. The current proven ${componentLabel} baseline expects Tailwind CSS v4.`);
+        }
+        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}.`,
+        ];
+    }
+}
+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)) {
+            candidates.add(absolutePath);
+        }
+    }
+    const angularJsonPaths = findFilesUpward(targetRoot, 'angular.json');
+    for (const angularJsonPath of angularJsonPaths) {
+        for (const resolvedFromWorkspace of resolveStylesEntriesFromAngularWorkspace(angularJsonPath, targetRoot)) {
+            candidates.add(resolvedFromWorkspace);
+        }
+    }
+    return [...candidates];
+}
+export function isDemoTarget(targetRoot) {
+    return (existsSync(LOCAL_REPO_DEMO_ROOT) &&
+        path.resolve(targetRoot) === path.resolve(LOCAL_REPO_DEMO_ROOT));
+}
+export function toPosixPath(filePath) {
+    return filePath.split(path.sep).join(path.posix.sep);
+}
+export function toConfigRelativePath(filePath) {
+    const posixPath = toPosixPath(filePath);
+    return posixPath.startsWith('.') ? posixPath : `./${posixPath}`;
+}
+export function toTargetRelativePath(targetRoot, filePath) {
+    return toPosixPath(path.relative(targetRoot, filePath));
+}
+function walkForAngularApps(root, currentDir, matches) {
+    for (const entry of readdirSync(currentDir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+            if (shouldSkipDirectory(entry.name)) {
+                continue;
+            }
+            walkForAngularApps(root, path.join(currentDir, entry.name), matches);
+            continue;
+        }
+        if (!entry.isFile() || entry.name !== 'tsconfig.app.json') {
+            continue;
+        }
+        const candidateRoot = currentDir;
+        if (!looksLikeAngularAppRoot(candidateRoot)) {
+            continue;
+        }
+        const relativeRoot = path.relative(root, candidateRoot) || '.';
+        matches.add(toPosixPath(relativeRoot));
+    }
+}
+function shouldSkipDirectory(name) {
+    return ['.angular', '.git', '.playwright-cli', 'dist', 'node_modules', 'output'].includes(name);
+}
+function detectProjectFramework(targetRoot) {
+    if (findNearestFileUpward(targetRoot, 'ionic.config.json')) {
+        return 'ionic-angular';
+    }
+    const packageJsonPath = findNearestFileUpward(targetRoot, 'package.json');
+    if (packageJsonPath && packageJsonUsesIonicAngular(packageJsonPath)) {
+        return 'ionic-angular';
+    }
+    return 'angular';
+}
+function packageJsonUsesIonicAngular(packageJsonPath) {
+    try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        return Boolean(packageJson.dependencies?.['@ionic/angular'] ??
+            packageJson.devDependencies?.['@ionic/angular']);
+    }
+    catch {
+        return false;
+    }
+}
+function resolveStylesEntriesFromAngularWorkspace(angularJsonPath, targetRoot) {
+    try {
+        const angularJson = JSON.parse(readFileSync(angularJsonPath, 'utf8'));
+        const workspaceRoot = path.dirname(angularJsonPath);
+        const projects = Object.values(angularJson.projects ?? {});
+        const matchingProjects = projects.filter((project) => projectMatchesTargetRoot(project, workspaceRoot, targetRoot));
+        const candidateProjects = matchingProjects.length > 0
+            ? matchingProjects
+            : 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) {
+                const input = typeof style === 'string' ? style : style.input;
+                if (!input) {
+                    continue;
+                }
+                const absolutePath = path.resolve(workspaceRoot, input);
+                if (existsSync(absolutePath)) {
+                    matches.push(absolutePath);
+                }
+            }
+        }
+        return matches;
+    }
+    catch {
+        return [];
+    }
+}
+function projectMatchesTargetRoot(project, workspaceRoot, targetRoot) {
+    const resolvedTargetRoot = path.resolve(targetRoot);
+    const candidateRoots = new Set([path.resolve(workspaceRoot, project.root ?? '.')]);
+    if (project.sourceRoot) {
+        candidateRoots.add(path.resolve(workspaceRoot, path.dirname(project.sourceRoot)));
+    }
+    for (const candidateRoot of candidateRoots) {
+        if (path.resolve(candidateRoot) === resolvedTargetRoot) {
+            return true;
+        }
+    }
+    return false;
+}
+function findNearestAngularJsonDisplayPath(targetRoot) {
+    const nearestAngularJsonPath = findNearestFileUpward(targetRoot, 'angular.json');
+    return nearestAngularJsonPath ? nearestAngularJsonPath : path.join(targetRoot, 'angular.json');
+}
+function findFilesUpward(startDir, fileName) {
+    const matches = [];
+    let currentDir = path.resolve(startDir);
+    let reachedRoot = false;
+    while (!reachedRoot) {
+        const candidatePath = path.join(currentDir, fileName);
+        if (existsSync(candidatePath)) {
+            matches.push(candidatePath);
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            reachedRoot = true;
+            continue;
+        }
+        currentDir = parentDir;
+    }
+    return matches;
+}
+function findNearestFileUpward(startDir, fileName) {
+    return findFilesUpward(startDir, fileName)[0];
+}
+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.1.2",
+  "version": "0.3.0",
   "type": "module",
   "description": "Copy-paste ownership CLI for Trine UI components.",
   "main": "./dist/index.js",