@trineui/cli 0.1.2 → 0.2.0

package/README.md

@@ -6,25 +6,36 @@ 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>
 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
 - `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`
@@ -38,5 +49,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,22 +1,25 @@
 #!/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 { initProject } from "./init.js";
+import { findAngularAppTargets, looksLikeAngularAppRoot } from "./project.js";
 const HELP_TEXT = `Usage:
+  npx @trineui/cli@latest init [--target <app-root>]
   npx @trineui/cli@latest add button [--target <app-root>]
+  trine init [--target <app-root>]
   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>
+  - 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>
 
 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 now 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
@@ -24,19 +27,28 @@ Notes:
   - 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;
+    const [command, secondArg, ...rest] = argv;
+    if (command === 'init') {
+        const selection = resolveTargetSelection(process.cwd(), argv.slice(1), 'trine init');
+        const result = initProject({
+            target: selection.target,
+            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 selection = resolveTargetSelection(process.cwd(), rest, `trine add ${secondArg}`);
     const result = addButton({
-        target,
+        target: selection.target,
         cwd: process.cwd(),
     });
-    printSuccess('button', result);
+    printAddSuccess(secondArg, result, selection);
 }
 function readTarget(argv) {
     for (let index = 0; index < argv.length; index += 1) {
@@ -46,82 +58,90 @@ function readTarget(argv) {
     }
     return undefined;
 }
-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, argv, commandLabel) {
+    const explicitTarget = readTarget(argv);
+    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',
+    };
+}
+function printInitSuccess(result, selection) {
+    const displayTarget = toDisplayTarget(process.cwd(), result.targetRoot);
+    const stylesheetDisplay = toDisplayFilePath(result.targetRoot, result.targetStylesEntry);
     const lines = [
-        `trine add ${component} completed.`,
+        'trine init completed.',
         `Target: ${displayTarget}`,
-        '',
-        'Copied files:',
-        ...result.copiedFiles.map((file) => `- ${file}`),
-        '',
-        'Created or updated:',
-        ...result.updatedFiles.map((file) => `- ${file}`),
+        `Framework: ${result.framework}`,
+        `Resolved stylesheet entry: ${stylesheetDisplay}`,
     ];
+    if (selection.mode === 'auto-detected') {
+        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 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 findAngularAppTargets(root) {
-    const matches = new Set();
-    walkForAngularApps(root, root, matches);
-    return [...matches].sort((left, right) => left.localeCompare(right));
-}
-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 toDisplayTarget(cwd, targetRoot) {
+    const relativeTarget = path.relative(cwd, targetRoot) || '.';
+    return relativeTarget.startsWith('..') ? targetRoot : relativeTarget;
 }
-function toPosixPath(filePath) {
-    return filePath.split(path.sep).join(path.posix.sep);
+function toDisplayFilePath(targetRoot, filePath) {
+    return path.relative(targetRoot, filePath) || '.';
 }
 try {
     main(process.argv.slice(2));

package/dist/init.js

@@ -0,0 +1,54 @@
+import path from 'node:path';
+import { ensureSharedStyleBaseline, ensureStylesImport, ensureTsconfigAlias, ensureUiRootBarrel, isDemoTarget, readTargetDependencyWarnings, resolveSupportedProjectTarget, toTargetRelativePath, } from "./project.js";
+export function initProject(options) {
+    const targetRoot = path.resolve(options.cwd, options.target);
+    const { framework, targetStylesEntry, targetTsconfig } = resolveSupportedProjectTarget('trine init', targetRoot);
+    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);
+    if (uiRootResult.created) {
+        createdFiles.push(uiRootResult.file);
+    }
+    else {
+        reusedFiles.push(uiRootResult.file);
+    }
+    const tsconfigDisplayPath = toTargetRelativePath(targetRoot, targetTsconfig);
+    if (ensureTsconfigAlias(targetTsconfig, targetRoot, options.cwd)) {
+        updatedFiles.push(tsconfigDisplayPath);
+    }
+    else {
+        reusedFiles.push(tsconfigDisplayPath);
+    }
+    const stylesDisplayPath = toTargetRelativePath(targetRoot, targetStylesEntry);
+    const stylesResult = ensureStylesImport(targetStylesEntry);
+    if (stylesResult.updated) {
+        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,
+        framework,
+        targetStylesEntry,
+        createdFiles,
+        updatedFiles,
+        reusedFiles,
+        warnings,
+    };
+}

package/dist/project.js

@@ -0,0 +1,361 @@
+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) {
+    const targetAppDir = path.join(targetRoot, 'src', 'app');
+    const targetTsconfig = path.join(targetRoot, 'tsconfig.app.json');
+    const targetStylesEntry = resolveStylesEntry(targetRoot);
+    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,
+        targetStylesEntry,
+        framework,
+        missingPaths,
+    };
+}
+export function resolveSupportedProjectTarget(commandLabel, targetRoot) {
+    const inspection = inspectProjectTarget(targetRoot);
+    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 stylesDestDir = path.join(targetRoot, 'src', 'styles');
+    const createdFiles = [];
+    const reusedFiles = [];
+    const warnings = [];
+    mkdirSync(stylesDestDir, { recursive: true });
+    for (const sourceFile of STYLE_SOURCE_FILES) {
+        const templatePath = path.join(TEMPLATE_ROOT, sourceFile);
+        const destinationPath = path.join(stylesDestDir, path.basename(sourceFile));
+        const relativeDestination = toTargetRelativePath(targetRoot, destinationPath);
+        if (!existsSync(destinationPath)) {
+            copyFileSync(templatePath, destinationPath);
+            createdFiles.push(relativeDestination);
+            continue;
+        }
+        if (readFileSync(destinationPath, 'utf8') !== readFileSync(templatePath, 'utf8')) {
+            warnings.push(`${relativeDestination} already exists and was preserved. Review it manually if the delivered ${componentLabel} expects newer shared styling baseline content.`);
+            continue;
+        }
+        reusedFiles.push(relativeDestination);
+    }
+    return {
+        createdFiles,
+        reusedFiles,
+        warnings,
+    };
+}
+export function ensureUiRootBarrel(targetRoot) {
+    const uiRootPath = path.join(targetRoot, 'src', 'app', 'components', 'ui', 'index.ts');
+    if (existsSync(uiRootPath)) {
+        return {
+            created: false,
+            file: toTargetRelativePath(targetRoot, uiRootPath),
+        };
+    }
+    mkdirSync(path.dirname(uiRootPath), { recursive: true });
+    writeFileSync(uiRootPath, '\n');
+    return {
+        created: true,
+        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 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(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;
+    }
+    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 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';"),
+    };
+}
+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) {
+    for (const relativePath of CONVENTIONAL_STYLE_ENTRY_PATHS) {
+        const absolutePath = path.join(targetRoot, relativePath);
+        if (existsSync(absolutePath)) {
+            return absolutePath;
+        }
+    }
+    const angularJsonPaths = findFilesUpward(targetRoot, 'angular.json');
+    for (const angularJsonPath of angularJsonPaths) {
+        const resolvedFromWorkspace = resolveStylesEntryFromAngularWorkspace(angularJsonPath, targetRoot);
+        if (resolvedFromWorkspace) {
+            return resolvedFromWorkspace;
+        }
+    }
+    return undefined;
+}
+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 resolveStylesEntryFromAngularWorkspace(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
+                : [];
+        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)) {
+                    return absolutePath;
+                }
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+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);
+}

package/package.json

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