@trineui/cli 0.2.0 → 0.4.0

package/README.md

@@ -1,54 +1,204 @@
 # @trineui/cli
 
-Canonical public package:
+`@trineui/cli` is the public Trine CLI for the current Button-first baseline.
+
+Current public baseline:
+
+- guided `init`
+- `add button`
+- Button is the only public component baseline in scope
+- Angular has the strongest proof coverage right now
+
+Canonical public flow:
 
 ```bash
+npx @trineui/cli@latest init
 npx @trineui/cli@latest add button
 ```
 
-Registry status note:
+`init` is guided by default. Use `--yes` for non-interactive mode.
+
+## What Works Right Now
+
+The current public Trine baseline is intentionally narrow.
+
+It supports:
+
+- preparing a supported Angular app with `init`
+- delivering a consumer-owned Button with `add button`
+- wiring a local `@trine/ui` alias into the target app
+- injecting the Trine styling baseline into the target app's real global stylesheet entry
+- local customization by editing `button.skin.ts` or adding semantic variable overrides below the Trine-managed block
+
+It does not currently support:
+
+- more components than Button
+- automatic prerequisite installation
+- automatic usage-surface scaffolding
+- broad framework coverage claims beyond the current Angular-first baseline
+
+## Before You Start
+
+### Supported target shape
+
+The current proven target shape is an Angular app with:
+
+- `src/app`
+- `tsconfig.app.json`
+- a valid global stylesheet entry such as:
+  - `src/styles.scss`
+  - `src/styles.css`
+  - `src/global.scss`
+  - or a build styles entry resolved from `angular.json`
+
+`init` can distinguish `angular` and `ionic-angular`, but Angular has the strongest live proof coverage today.
+
+### Manual prerequisites
+
+The live CLI still expects these prerequisites to be installed manually in the target repo.
+
+For the current Button baseline, these are hard requirements rather than optional enhancements:
+
+```bash
+npm install class-variance-authority
+npm install -D tailwindcss@^4 @tailwindcss/postcss postcss
+```
+
+The current baseline also expects PostCSS configuration in the target repo:
+
+`.postcssrc.json`
+
+```json
+{
+  "plugins": {
+    "@tailwindcss/postcss": {}
+  }
+}
+```
+
+Use a Node LTS line supported by Angular 21 in the target repo. Odd-numbered Node releases can build with warnings.
+
+For the styling-layer contract behind these requirements, see:
+
+- `docs/01-overview/05-styling-contract.md`
+
+## Quickstart
+
+### 1. Run guided init
+
+From the app root:
+
+```bash
+npx @trineui/cli@latest init
+```
+
+If you prefer non-interactive mode:
 
-- 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
+```bash
+npx @trineui/cli@latest init --yes
+```
 
-Repository-local current command surface:
+If you are inside a workspace root or want to target a specific app:
 
 ```bash
-trine init --target <app-root>
-trine add button --target <app-root>
+npx @trineui/cli@latest init --target /absolute/path/to/app
 ```
 
-Notes:
+`init` currently:
+
+- detects the target app
+- detects `angular` vs `ionic-angular`
+- resolves the target stylesheet entry
+- previews file changes before mutation
+- injects a named Trine-managed styling block into the resolved global stylesheet entry
+- ensures `src/app/components/ui/index.ts`
+- ensures local `@trine/ui` in `tsconfig.app.json`
+- ensures the stylesheet block includes semantic tokens, `.dark` overrides, and Tailwind v4 `@theme inline` mapping
+
+`init` does not currently install Tailwind/PostCSS/CVA or generate `.postcssrc.json` for you.
+
+Rerunning `init` on an already prepared target should no-op cleanly.
+
+### 2. Deliver Button
+
+```bash
+npx @trineui/cli@latest add button
+```
+
+Or explicitly:
+
+```bash
+npx @trineui/cli@latest add button --target /absolute/path/to/app
+```
+
+`add button` currently delivers:
+
+- `src/app/components/ui/button/button.ts`
+- `src/app/components/ui/button/button.html`
+- `src/app/components/ui/button/button.skin.ts`
+- `src/app/components/ui/button/index.ts`
+- `src/app/components/ui/index.ts`
+
+It fails clearly if consumer-owned Button files already exist. It does not silently overwrite them.
 
-- `init` is now the preferred first step for project readiness; `add button` still works without it for backward compatibility
-- `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>`
-- 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
-- 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`
-- for `apps/demo`, `@trine/ui` resolves locally for delivered components while `@trine/ui/*` temporarily bridges non-localized components back to the authoring source
-- the delivered shared styling baseline is `tokens.css` + `trine-consumer.css`
-- the current proven target dependency baseline is Angular 21, Tailwind CSS v4, and `class-variance-authority`
-- the current proven target shape accepts a global stylesheet entry such as `src/styles.scss`, `src/styles.css`, or `src/global.scss` when it is resolved from `angular.json`
-- use a Node LTS line supported by Angular 21 in the target repo; odd-numbered Node releases can build with warnings
-- when `package.json` is present in the target root, the CLI warns if Tailwind CSS v4 or `class-variance-authority` are missing
+### 3. Render a small proof
 
-Local package proof equivalent:
+Import `TrineButton` from local `@trine/ui` and render a small proof surface:
+
+```ts
+import { Component } from '@angular/core';
+import { TrineButton } from '@trine/ui';
+
+@Component({
+  selector: 'app-root',
+  imports: [TrineButton],
+  template: `
+    <trine-button>Primary action</trine-button>
+    <trine-button variant="secondary">Secondary action</trine-button>
+    <trine-button [loading]="true">Saving</trine-button>
+  `,
+})
+export class App {}
+```
+
+### 4. Build the target app
 
 ```bash
-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
+npm run build
 ```
+
+Successful verification usually means:
+
+- the app builds
+- `@trine/ui` resolves to local consumer source
+- the resolved stylesheet entry contains a Trine-managed baseline block
+- Button renders from local delivered files
+
+## Customize Locally
+
+Trine uses a copy-paste ownership model.
+
+After delivery, the consumer repo owns the visual layer.
+
+The two main local customization paths are:
+
+- edit `src/app/components/ui/button/button.skin.ts`
+- add semantic variable overrides below the Trine-managed block in the resolved global stylesheet entry
+
+This is the intended model. Trine does not keep runtime ownership of the Button visuals after delivery.
+
+## Current Limitations
+
+- Button-only public baseline
+- manual prerequisites still required
+- usage surface is not scaffolded automatically
+- Angular has the strongest live proof coverage; Ionic Angular coverage is narrower
+- multiple target apps still require `--target` or guided selection
+- `src/styles.scss` and `src/global.scss` currently work, but Angular 21 surfaces a Sass deprecation warning for `@import 'tailwindcss';`
+- the baseline is intentionally narrow and not yet a broader component platform
+
+## Full Walkthrough
+
+For a fuller repo-level walkthrough of the current baseline, see:
+
+- `docs/01-overview/04-cli-getting-started.md`

package/dist/add-component.js

@@ -1,6 +1,6 @@
 import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
-import { TEMPLATE_ROOT, ensureLinesFile, ensureSharedStyleBaseline, ensureStylesImport, ensureTsconfigAlias, isDemoTarget, readTargetDependencyWarnings, resolveSupportedProjectTarget, toTargetRelativePath, } from "./project.js";
+import { TEMPLATE_ROOT, ensureLinesFile, ensureTrineStylesheetBaseline, 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 = [
     {
@@ -76,10 +76,9 @@ export function addComponent(manifest, options) {
         copyFileSync(source, destination);
     }
     const componentCopiedFiles = componentCopyTargets.map(({ destination }) => toTargetRelativePath(targetRoot, destination));
-    const sharedStylesResult = ensureSharedStyleBaseline(targetRoot, manifest.componentLabel);
-    const copiedFiles = [...componentCopiedFiles, ...sharedStylesResult.createdFiles];
+    const copiedFiles = [...componentCopiedFiles];
     const updatedFiles = [];
-    const warnings = [...sharedStylesResult.warnings];
+    const warnings = [];
     const componentBarrelPath = path.join(componentDestDir, 'index.ts');
     if (ensureLinesFile(componentBarrelPath, [manifest.barrelLine])) {
         updatedFiles.push(toTargetRelativePath(targetRoot, componentBarrelPath));
@@ -94,12 +93,13 @@ export function addComponent(manifest, options) {
     if (ensureTsconfigAlias(targetTsconfig, targetRoot, options.cwd)) {
         updatedFiles.push(toTargetRelativePath(targetRoot, targetTsconfig));
     }
-    const stylesResult = ensureStylesImport(targetStylesEntry);
+    const stylesResult = ensureTrineStylesheetBaseline(targetRoot, targetStylesEntry);
     if (stylesResult.updated) {
         updatedFiles.push(toTargetRelativePath(targetRoot, targetStylesEntry));
     }
+    warnings.push(...stylesResult.warnings);
     if (stylesResult.authoringImportStillPresent) {
-        warnings.push(`${toTargetRelativePath(targetRoot, targetStylesEntry)} still imports @trine/ui/styles/trine.css for the broader demo authoring baseline.`);
+        warnings.push(`${toTargetRelativePath(targetRoot, targetStylesEntry)} keeps the repo-local @trine/ui/styles/trine.css authoring entry so apps/demo can still validate non-localized components during local development.`);
     }
     if (isDemoTarget(targetRoot)) {
         warnings.push('apps/demo keeps non-localized components on a temporary @trine/ui/* bridge back to packages/ui so the full demo app can still build while delivered components resolve locally.');

package/dist/index.js

@@ -1,38 +1,60 @@
 #!/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
+  - init owns target detection, framework detection, stylesheet resolution, Trine-managed global stylesheet injection, and local @trine/ui alias setup
+  - 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
+  - the current proven styling/runtime baseline requires Tailwind CSS v4, PostCSS with @tailwindcss/postcss, 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
+  - init injects a Trine-managed styling block into the resolved global stylesheet entry instead of copying separate shared CSS files
   - @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,14 +238,14 @@ 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'));
     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.');
+    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.', '- If you want token-level customization, add semantic variable overrides below the Trine-managed block in the global stylesheet instead of editing inside the managed block.');
     console.log(lines.join('\n'));
 }
 function printAddSuccess(component, result, selection) {
@@ -121,7 +260,7 @@ function printAddSuccess(component, result, selection) {
     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.`, '- For future setup in this repo, prefer running trine init first so project-level Trine baseline files are already in place.');
+    lines.push('', 'Manual next steps:', `- Ensure the target repo has Tailwind CSS v4, PostCSS with @tailwindcss/postcss, 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 if you want component-level local customization.`, '- Add semantic token overrides below the Trine-managed global stylesheet block if you want app-level visual customization that survives rerunning init.', '- For future setup in this repo, prefer running trine init first so the project-level Trine baseline is already in place.');
     if (isRepoDemoVerification) {
         lines.push('- Open /validation-shell and review the CLI delivery proof section for the temporary demo verification path.');
     }
@@ -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,15 @@
 import path from 'node:path';
-import { ensureSharedStyleBaseline, ensureStylesImport, ensureTsconfigAlias, ensureUiRootBarrel, isDemoTarget, readTargetDependencyWarnings, resolveSupportedProjectTarget, toTargetRelativePath, } from "./project.js";
-export function initProject(options) {
+import { ensureTrineStylesheetBaseline, ensureTsconfigAlias, ensureUiRootBarrel, inspectTrineStylesheetBaseline, 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');
-    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,22 +17,23 @@ 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 = inspectTrineStylesheetBaseline(targetRoot, targetStylesEntry);
+    if (stylesResult.needsUpdate) {
         updatedFiles.push(stylesDisplayPath);
     }
     else {
         reusedFiles.push(stylesDisplayPath);
     }
+    warnings.push(...stylesResult.warnings);
     if (stylesResult.authoringImportStillPresent) {
-        warnings.push(`${stylesDisplayPath} still imports @trine/ui/styles/trine.css for a broader authoring baseline outside the local Trine consumer setup.`);
+        warnings.push(`${stylesDisplayPath} keeps the repo-local @trine/ui/styles/trine.css authoring entry so apps/demo can still validate non-localized components during local development.`);
     }
     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.');
@@ -44,6 +43,7 @@ export function initProject(options) {
     }
     return {
         targetRoot,
+        targetTsconfig,
         framework,
         targetStylesEntry,
         createdFiles,
@@ -52,3 +52,14 @@ export function initProject(options) {
         warnings,
     };
 }
+export function applyInitPlan(plan, options) {
+    ensureUiRootBarrel(plan.targetRoot);
+    ensureTsconfigAlias(plan.targetTsconfig, plan.targetRoot, options.cwd);
+    ensureTrineStylesheetBaseline(plan.targetRoot, plan.targetStylesEntry);
+    return plan;
+}
+export function initProject(options) {
+    return applyInitPlan(planInitProject(options), {
+        cwd: options.cwd,
+    });
+}