@nooeh/cli 0.1.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/add.d.ts

@@ -0,0 +1,7 @@
+export type AddOptions = {
+    defaults?: boolean;
+    "dry-run"?: boolean;
+    skipDependencyInstall?: boolean;
+    "skip-dependencies"?: boolean;
+} & Record<string, boolean | string | undefined>;
+export declare function add(projectDirectory: string, componentName: string, options?: AddOptions): Promise<void>;

package/dist/add.js

@@ -0,0 +1,105 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { defaultConfig, hasConfig, readConfig, resolveAliasPath, resolveTokensPath, } from "./config.js";
+import { installDependencies } from "./dependencies.js";
+import { init } from "./init.js";
+import { resolveComponent } from "./registry.js";
+function isNotFoundError(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function askYesNo(question, defaultValue) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return defaultValue;
+    const readline = createInterface({ input: process.stdin, output: process.stdout });
+    const defaultLabel = defaultValue ? "Y/n" : "y/N";
+    try {
+        const answer = (await readline.question(`${question} (${defaultLabel}) `)).trim().toLowerCase();
+        if (!answer)
+            return defaultValue;
+        return answer === "y" || answer === "yes";
+    }
+    finally {
+        readline.close();
+    }
+}
+async function writeSource(source, targetPath, confirmOverwrite) {
+    try {
+        const currentSource = await readFile(targetPath, "utf8");
+        if (currentSource === source)
+            return "unchanged";
+        if (!(await confirmOverwrite()))
+            throw new Error("Component installation canceled.");
+    }
+    catch (error) {
+        if (!isNotFoundError(error))
+            throw error;
+    }
+    await mkdir(dirname(targetPath), { recursive: true });
+    await writeFile(targetPath, source, "utf8");
+    return "written";
+}
+function resolveTargetPath(uiDirectory, filePath) {
+    if (isAbsolute(filePath))
+        throw new Error(`Registry file path must be relative: ${filePath}`);
+    const targetPath = resolve(uiDirectory, filePath);
+    const relativePath = relative(uiDirectory, targetPath);
+    if (relativePath === ".." || relativePath.startsWith(`..${"/"}`) || isAbsolute(relativePath)) {
+        throw new Error(`Registry file path must stay inside the UI directory: ${filePath}`);
+    }
+    return targetPath;
+}
+function replaceTokenImport(source, targetPath, tokenDirectory) {
+    const tokenModulePath = join(tokenDirectory, "tokens.stylex.ts");
+    const relativePath = relative(dirname(targetPath), tokenModulePath)
+        .replace(/\.ts$/, "")
+        .split(sep)
+        .join("/");
+    const tokenModule = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+    return source.replaceAll("@nooeh/tokens/tokens.stylex", tokenModule);
+}
+export async function add(projectDirectory, componentName, options = {}) {
+    if (!componentName)
+        throw new Error("Enter a component name to add.");
+    const shouldInitialize = !(await hasConfig(projectDirectory));
+    if (shouldInitialize && !options["dry-run"]) {
+        await init(projectDirectory, {
+            ...options,
+            "skip-dependencies": options.skipDependencyInstall || options["skip-dependencies"],
+        });
+    }
+    const config = options["dry-run"] && shouldInitialize ? defaultConfig : await readConfig(projectDirectory);
+    const resolved = await resolveComponent(componentName);
+    const uiDirectory = await resolveAliasPath(projectDirectory, config.aliases.ui);
+    const tokenDirectory = resolveTokensPath(projectDirectory, config.tokens);
+    let isOverwriteConfirmed = false;
+    async function confirmOverwrite() {
+        if (isOverwriteConfirmed)
+            return true;
+        isOverwriteConfirmed = await askYesNo("Files with the same names already exist. Overwrite all?", false);
+        return isOverwriteConfirmed;
+    }
+    for (const file of resolved.files) {
+        const targetPath = resolveTargetPath(uiDirectory, file.path);
+        if (options["dry-run"]) {
+            console.log(`Will add: ${targetPath}`);
+            continue;
+        }
+        await writeSource(replaceTokenImport(file.content, targetPath, tokenDirectory), targetPath, confirmOverwrite);
+    }
+    const shouldInstallDependencies = resolved.externalDependencies.length > 0 &&
+        !options.skipDependencyInstall &&
+        !options["skip-dependencies"] &&
+        !options["dry-run"] &&
+        (await askYesNo(`Install external dependencies (${resolved.externalDependencies.join(", ")})?`, true));
+    if (shouldInstallDependencies) {
+        await installDependencies(projectDirectory, resolved.externalDependencies);
+    }
+    const primaryExport = resolved.primaryExport;
+    if (options["dry-run"]) {
+        console.log(`Will add ${componentName}.`);
+        return;
+    }
+    console.log(`Added ${componentName}.`);
+    console.log(`import { ${primaryExport} } from "${config.aliases.ui}/${componentName}"`);
+}

package/dist/arguments.d.ts

@@ -0,0 +1,15 @@
+export type CliOptions = Record<string, boolean | string | undefined> & {
+    cwd?: string;
+    defaults?: boolean;
+    framework?: string;
+    "dry-run"?: boolean;
+    force?: boolean;
+    "skip-dependencies"?: boolean;
+    tokens?: string;
+    "ui-alias"?: string;
+};
+export declare function parseArguments(arguments_: readonly string[]): {
+    command: string;
+    options: CliOptions;
+    positionals: string[];
+};

package/dist/arguments.js

@@ -0,0 +1,21 @@
+export function parseArguments(arguments_) {
+    const [command, ...rest] = arguments_;
+    const options = {};
+    const positionals = [];
+    for (let index = 0; index < rest.length; index += 1) {
+        const argument = rest[index];
+        if (!argument.startsWith("--")) {
+            positionals.push(argument);
+            continue;
+        }
+        const name = argument.slice(2);
+        const nextArgument = rest[index + 1];
+        if (!nextArgument || nextArgument.startsWith("--")) {
+            options[name] = true;
+            continue;
+        }
+        options[name] = nextArgument;
+        index += 1;
+    }
+    return { command, options, positionals };
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { run } from "./index.js";
+if (!(await run()))
+    process.exitCode = 1;

package/dist/config.d.ts

@@ -0,0 +1,16 @@
+export declare const configFileName = "nooeh.json";
+export declare const configVersion = 2;
+export type NooehConfig = {
+    aliases: {
+        ui: string;
+    };
+    tokens: string;
+    version?: number;
+};
+export declare const defaultConfig: NooehConfig;
+export declare function hasConfig(projectDirectory: string): Promise<boolean>;
+export declare function validateConfig(config: unknown): NooehConfig;
+export declare function readConfig(projectDirectory: string): Promise<NooehConfig>;
+export declare function writeConfig(projectDirectory: string, config: NooehConfig): Promise<string>;
+export declare function resolveTokensPath(projectDirectory: string, tokens: string): string;
+export declare function resolveAliasPath(projectDirectory: string, alias: string): Promise<string>;

package/dist/config.js

@@ -0,0 +1,114 @@
+import { access, readFile, writeFile } from "node:fs/promises";
+import { isAbsolute, relative, resolve } from "node:path";
+export const configFileName = "nooeh.json";
+export const configVersion = 2;
+export const defaultConfig = {
+    aliases: { ui: "@/components/ui" },
+    tokens: "src/styles/nooeh",
+    version: configVersion,
+};
+export async function hasConfig(projectDirectory) {
+    try {
+        await access(resolve(projectDirectory, configFileName));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function ensureRelativePath(projectDirectory, path, name) {
+    const absolutePath = resolve(projectDirectory, path);
+    const relativePath = relative(projectDirectory, absolutePath);
+    if (isAbsolute(relativePath) || relativePath.startsWith("..")) {
+        throw new Error(`${name} must be inside the project directory.`);
+    }
+}
+export function validateConfig(config) {
+    const candidate = config;
+    if (!candidate.aliases || typeof candidate.aliases.ui !== "string" || !candidate.aliases.ui) {
+        throw new Error("Configure aliases.ui.");
+    }
+    if (candidate.version !== undefined && candidate.version !== configVersion) {
+        throw new Error(`Unsupported nooeh.json version: ${String(candidate.version)}`);
+    }
+    if (typeof candidate.tokens !== "string" || !candidate.tokens.trim()) {
+        throw new Error("Configure tokens.");
+    }
+    if (isAbsolute(candidate.tokens)) {
+        throw new Error("tokens must be inside the project directory.");
+    }
+    return {
+        aliases: { ui: candidate.aliases.ui },
+        tokens: candidate.tokens,
+        version: configVersion,
+    };
+}
+function isNotFoundError(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+export async function readConfig(projectDirectory) {
+    const configPath = resolve(projectDirectory, configFileName);
+    try {
+        const config = JSON.parse(await readFile(configPath, "utf8"));
+        return validateConfig(config);
+    }
+    catch (error) {
+        if (isNotFoundError(error)) {
+            throw new Error("nooeh.json was not found. Run `nooeh init` first.");
+        }
+        throw error;
+    }
+}
+export async function writeConfig(projectDirectory, config) {
+    const validatedConfig = validateConfig(config);
+    ensureRelativePath(projectDirectory, validatedConfig.tokens, "tokens");
+    const configPath = resolve(projectDirectory, configFileName);
+    await writeFile(configPath, `${JSON.stringify(validatedConfig, null, 2)}\n`, "utf8");
+    return configPath;
+}
+export function resolveTokensPath(projectDirectory, tokens) {
+    ensureRelativePath(projectDirectory, tokens, "tokens");
+    return resolve(projectDirectory, tokens);
+}
+function findAliasTarget(alias, paths) {
+    for (const [pattern, targets] of Object.entries(paths ?? {})) {
+        const target = targets[0];
+        if (!target)
+            continue;
+        const starIndex = pattern.indexOf("*");
+        if (starIndex === -1) {
+            if (alias === pattern)
+                return target;
+            continue;
+        }
+        const prefix = pattern.slice(0, starIndex);
+        const suffix = pattern.slice(starIndex + 1);
+        if (!alias.startsWith(prefix) || !alias.endsWith(suffix))
+            continue;
+        const value = alias.slice(prefix.length, alias.length - suffix.length);
+        return target.replaceAll("*", value);
+    }
+    return undefined;
+}
+export async function resolveAliasPath(projectDirectory, alias) {
+    for (const fileName of ["tsconfig.json", "jsconfig.json"]) {
+        const configPath = resolve(projectDirectory, fileName);
+        try {
+            const projectConfig = JSON.parse(await readFile(configPath, "utf8"));
+            const compilerOptions = projectConfig.compilerOptions ?? {};
+            const aliasTarget = findAliasTarget(alias, compilerOptions.paths);
+            if (!aliasTarget)
+                continue;
+            const baseDirectory = resolve(projectDirectory, compilerOptions.baseUrl ?? ".");
+            const resolvedPath = resolve(baseDirectory, aliasTarget);
+            ensureRelativePath(projectDirectory, resolvedPath, "UI");
+            return resolvedPath;
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                continue;
+            throw error;
+        }
+    }
+    throw new Error(`Could not find the ${alias} alias in compilerOptions.paths of tsconfig.json or jsconfig.json.`);
+}

package/dist/dependencies.d.ts

@@ -0,0 +1 @@
+export declare function installDependencies(projectDirectory: string, dependencies: readonly string[], isDevelopmentDependency?: boolean): Promise<void>;

package/dist/dependencies.js

@@ -0,0 +1,30 @@
+import { spawn } from "node:child_process";
+function detectPackageManager() {
+    const userAgent = process.env.npm_config_user_agent ?? "";
+    if (userAgent.startsWith("pnpm"))
+        return "pnpm";
+    if (userAgent.startsWith("yarn"))
+        return "yarn";
+    if (userAgent.startsWith("bun"))
+        return "bun";
+    return "npm";
+}
+export function installDependencies(projectDirectory, dependencies, isDevelopmentDependency = false) {
+    if (dependencies.length === 0)
+        return Promise.resolve();
+    const packageManager = detectPackageManager();
+    const developmentFlag = isDevelopmentDependency ? "-D" : undefined;
+    const arguments_ = packageManager === "npm"
+        ? ["install", developmentFlag, ...dependencies].filter((argument) => Boolean(argument))
+        : ["add", developmentFlag, ...dependencies].filter((argument) => Boolean(argument));
+    return new Promise((resolvePromise, reject) => {
+        const child = spawn(packageManager, arguments_, { cwd: projectDirectory, stdio: "inherit" });
+        child.on("error", reject);
+        child.on("exit", (code) => {
+            if (code === 0)
+                resolvePromise();
+            else
+                reject(new Error(`Dependency installation failed with exit code ${code}.`));
+        });
+    });
+}

package/dist/docs.d.ts

@@ -0,0 +1,2 @@
+export declare function list(): void;
+export declare function docs(componentName: string | undefined): void;

package/dist/docs.js

@@ -0,0 +1,23 @@
+import { registryItems } from "@nooeh/registry";
+function getComponentNames() {
+    return Object.keys(registryItems).sort();
+}
+export function list() {
+    console.log(getComponentNames().join("\n"));
+}
+export function docs(componentName) {
+    if (!componentName) {
+        list();
+        return;
+    }
+    const item = registryItems[componentName];
+    if (!item)
+        throw new Error(`Unknown component: ${componentName}`);
+    console.log(`${componentName}\n`);
+    console.log(`Install: pnpm dlx @nooeh/ui add ${componentName}`);
+    console.log(`Files:\n${item.files.map((file) => `  ${file}`).join("\n")}`);
+    console.log(`Dependencies:\n${item.dependencies.map((dependency) => `  ${dependency}`).join("\n")}`);
+    if (item.registryDependencies.length) {
+        console.log(`Also installs:\n${item.registryDependencies.map((dependency) => `  ${dependency}`).join("\n")}`);
+    }
+}

package/dist/doctor.d.ts

@@ -0,0 +1 @@
+export declare function doctor(projectDirectory: string): Promise<boolean>;

package/dist/doctor.js

@@ -0,0 +1,165 @@
+import { access, readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { hasConfig, readConfig, resolveAliasPath, resolveTokensPath } from "./config.js";
+async function readPackageJson(projectDirectory) {
+    try {
+        return JSON.parse(await readFile(resolve(projectDirectory, "package.json"), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readProjectFile(projectDirectory, fileName) {
+    try {
+        return await readFile(resolve(projectDirectory, fileName), "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+const entryFileNames = [
+    "src/main.tsx",
+    "src/main.jsx",
+    "src/main.ts",
+    "src/main.js",
+    "src/index.tsx",
+    "src/index.jsx",
+    "src/index.ts",
+    "src/index.js",
+    "src/app/layout.tsx",
+    "src/app/layout.jsx",
+    "app/layout.tsx",
+    "app/layout.jsx",
+];
+async function readEntrySources(projectDirectory) {
+    const sources = await Promise.all(entryFileNames.map(async (fileName) => readProjectFile(projectDirectory, fileName)));
+    return sources.filter((source) => source !== undefined);
+}
+async function hasStylexCompiler(projectDirectory) {
+    const configFileNames = [
+        "vite.config.ts",
+        "vite.config.mts",
+        "vite.config.js",
+        "vite.config.mjs",
+        "next.config.ts",
+        "next.config.mjs",
+        "next.config.js",
+        "webpack.config.ts",
+        "webpack.config.mjs",
+        "webpack.config.js",
+        "rsbuild.config.ts",
+        "rsbuild.config.mjs",
+        "rsbuild.config.js",
+        "rspack.config.ts",
+        "rspack.config.mjs",
+        "rspack.config.js",
+    ];
+    const sources = await Promise.all(configFileNames.map(async (fileName) => readProjectFile(projectDirectory, fileName)));
+    return sources.some((source) => source?.includes("@stylexjs/unplugin") && source.includes("stylex("));
+}
+function hasDependency(packageJson, dependency) {
+    return Boolean(packageJson?.dependencies?.[dependency] ?? packageJson?.devDependencies?.[dependency]);
+}
+export async function doctor(projectDirectory) {
+    const checks = [];
+    const packageJson = await readPackageJson(projectDirectory);
+    const entrySources = await readEntrySources(projectDirectory);
+    if (!(await hasConfig(projectDirectory))) {
+        checks.push({
+            detail: "Run `nooeh init` to configure the default UI alias.",
+            name: "nooeh.json",
+            status: "warn",
+        });
+    }
+    else {
+        const config = await readConfig(projectDirectory);
+        const uiDirectory = await resolveAliasPath(projectDirectory, config.aliases.ui);
+        checks.push({
+            detail: `${config.aliases.ui} → ${uiDirectory}`,
+            name: "UI alias",
+            status: "pass",
+        });
+        const tokenDirectory = resolveTokensPath(projectDirectory, config.tokens);
+        const tokenFiles = [
+            "color-palette.stylex.ts",
+            "tokens.stylex.ts",
+            "themes.stylex.ts",
+            "theme.ts",
+        ];
+        const hasTokenFiles = await Promise.all(tokenFiles.map(async (fileName) => {
+            try {
+                await access(resolve(tokenDirectory, fileName));
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }));
+        checks.push(hasTokenFiles.every(Boolean)
+            ? {
+                detail: `${config.tokens} contains local token sources.`,
+                name: "Local tokens",
+                status: "pass",
+            }
+            : {
+                detail: `Create local token sources in ${config.tokens} with \`nooeh init --force\`.`,
+                name: "Local tokens",
+                status: "warn",
+            });
+    }
+    checks.push(hasDependency(packageJson, "@stylexjs/stylex")
+        ? { detail: "@stylexjs/stylex is installed.", name: "StyleX runtime", status: "pass" }
+        : {
+            detail: "It is installed automatically by the first `nooeh add`. Use --skip-dependencies to skip installation.",
+            name: "StyleX runtime",
+            status: "warn",
+        });
+    checks.push((await hasStylexCompiler(projectDirectory))
+        ? {
+            detail: "A supported config enables the StyleX compiler.",
+            name: "StyleX compiler",
+            status: "pass",
+        }
+        : {
+            detail: "Configure the StyleX compiler for your bundler. Vite users can run `nooeh init --framework vite`.",
+            name: "StyleX compiler",
+            status: "warn",
+        });
+    checks.push(entrySources.some((source) => source.includes("./styles/nooeh.css") || source.includes("@nooeh/ui/global.css"))
+        ? {
+            detail: "An application entry imports nooeh global CSS.",
+            name: "Global CSS",
+            status: "pass",
+        }
+        : {
+            detail: "Import `src/styles/nooeh.css` from an application entry point.",
+            name: "Global CSS",
+            status: "warn",
+        });
+    checks.push(entrySources.some((source) => source.includes("applyNooehTheme()"))
+        ? {
+            detail: "An application entry applies a nooeh theme.",
+            name: "Theme application",
+            status: "pass",
+        }
+        : {
+            detail: "Call applyNooehTheme() before rendering your application.",
+            name: "Theme application",
+            status: "warn",
+        });
+    checks.push(hasDependency(packageJson, "@stylexjs/unplugin")
+        ? {
+            detail: "@stylexjs/unplugin is installed.",
+            name: "StyleX build plugin",
+            status: "pass",
+        }
+        : {
+            detail: "Add @stylexjs/unplugin to your bundler configuration, such as Vite or esbuild.",
+            name: "StyleX build plugin",
+            status: "warn",
+        });
+    for (const check of checks) {
+        console.log(`${check.status === "pass" ? "✓" : "!"} ${check.name}: ${check.detail}`);
+    }
+    return checks.every((check) => check.status === "pass");
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export declare function run(arguments_?: string[]): Promise<boolean>;

package/dist/index.js

@@ -0,0 +1,48 @@
+import { resolve } from "node:path";
+import { add } from "./add.js";
+import { parseArguments } from "./arguments.js";
+import { doctor } from "./doctor.js";
+import { docs, list } from "./docs.js";
+import { init } from "./init.js";
+import { newComponent } from "./new-component.js";
+export async function run(arguments_ = process.argv.slice(2)) {
+    const { command, options, positionals } = parseArguments(arguments_);
+    const projectDirectory = resolve(String(options.cwd ?? process.cwd()));
+    try {
+        if (command === "init") {
+            await init(projectDirectory, options);
+        }
+        else if (command === "add") {
+            await add(projectDirectory, positionals[0], options);
+        }
+        else if (command === "doctor") {
+            await doctor(projectDirectory);
+        }
+        else if (command === "docs") {
+            docs(positionals[0]);
+        }
+        else if (command === "list") {
+            list();
+        }
+        else if (command === "new") {
+            await newComponent(projectDirectory, positionals[0]);
+        }
+        else {
+            console.log(`Nooeh CLI
+
+Usage:
+  nooeh init
+  nooeh init --framework vite
+  nooeh add <component> [--skip-dependencies] [--dry-run]
+  nooeh doctor
+  nooeh list
+  nooeh docs [component]
+  nooeh new <kebab-case-name>`);
+        }
+        return true;
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return false;
+    }
+}

package/dist/init.d.ts

@@ -0,0 +1,2 @@
+import type { CliOptions } from "./arguments.js";
+export declare function init(projectDirectory: string, options: CliOptions): Promise<void>;

package/dist/init.js

@@ -0,0 +1,142 @@
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, relative, sep } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { configFileName, defaultConfig, hasConfig, resolveTokensPath, writeConfig, } from "./config.js";
+import { installDependencies } from "./dependencies.js";
+import { getTokenFiles } from "@nooeh/registry";
+async function ask(question, defaultValue, readline) {
+    const answer = await readline.question(`${question} (${defaultValue}) `);
+    return answer.trim() || defaultValue;
+}
+function getSourceDirectory(projectDirectory) {
+    return join(projectDirectory, "src");
+}
+async function readViteConfig(projectDirectory) {
+    const configFileNames = [
+        "vite.config.ts",
+        "vite.config.mts",
+        "vite.config.js",
+        "vite.config.mjs",
+    ];
+    for (const fileName of configFileNames) {
+        const path = join(projectDirectory, fileName);
+        try {
+            await access(path);
+            return { path, source: await readFile(path, "utf8") };
+        }
+        catch (error) {
+            if (typeof error === "object" &&
+                error !== null &&
+                "code" in error &&
+                error.code === "ENOENT") {
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw new Error("Could not find a Vite config file.");
+}
+function configureVite(source) {
+    const importLine = 'import stylex from "@stylexjs/unplugin/vite";';
+    const pluginPattern = /plugins:\s*\[([^\]]*)\]/s;
+    if (source.includes("stylex("))
+        return source;
+    if (!pluginPattern.test(source)) {
+        throw new Error("Could not safely update the Vite plugins array. Add stylex({ useCSSLayers: true }) manually.");
+    }
+    const withImport = source.includes(importLine) ? source : `${importLine}\n${source}`;
+    return withImport.replace(pluginPattern, (_, plugins) => {
+        const prefix = plugins.trim()
+            ? `stylex({ useCSSLayers: true }), ${plugins}`
+            : "stylex({ useCSSLayers: true })";
+        return `plugins: [${prefix}]`;
+    });
+}
+function toModuleSpecifier(fromDirectory, path) {
+    const source = relative(fromDirectory, path).replace(/\.ts$/, "").split(sep).join("/");
+    return source.startsWith(".") ? source : `./${source}`;
+}
+async function writeViteFiles(projectDirectory, tokenDirectory) {
+    const { path: configPath, source: configSource } = await readViteConfig(projectDirectory);
+    const configuredVite = configureVite(configSource);
+    const { entryPath, stylePath, themePath } = getNooehPaths(projectDirectory, tokenDirectory);
+    const entrySource = await readFile(entryPath, "utf8");
+    const styleImport = 'import "./styles/nooeh.css";';
+    const themeImport = `import { applyNooehTheme } from "${toModuleSpecifier(dirname(entryPath), themePath)}";`;
+    const themeApply = "applyNooehTheme();";
+    const imports = [styleImport, themeImport].filter((line) => !entrySource.includes(line));
+    const nextEntrySource = `${imports.join("\n")}\n${entrySource}`;
+    await writeNooehFiles(projectDirectory, tokenDirectory);
+    await writeFile(entryPath, nextEntrySource.includes(themeApply)
+        ? nextEntrySource
+        : `${imports.length ? `${imports.join("\n")}\n` : ""}${themeApply}\n${entrySource}`, "utf8");
+    await writeFile(configPath, configuredVite, "utf8");
+    console.log(`Configured Vite and created ${relative(projectDirectory, stylePath)}.`);
+}
+function getNooehPaths(projectDirectory, tokenDirectory) {
+    const sourceDirectory = getSourceDirectory(projectDirectory);
+    return {
+        entryPath: join(sourceDirectory, "main.tsx"),
+        stylePath: join(sourceDirectory, "styles", "nooeh.css"),
+        themePath: join(tokenDirectory, "theme.ts"),
+    };
+}
+async function writeNooehFiles(projectDirectory, tokenDirectory) {
+    const { entryPath, stylePath, themePath } = getNooehPaths(projectDirectory, tokenDirectory);
+    await mkdir(dirname(stylePath), { recursive: true });
+    await mkdir(tokenDirectory, { recursive: true });
+    await writeFileIfMissing(stylePath, '@import "@nooeh/ui/global.css";\n');
+    for (const file of await getTokenFiles()) {
+        await writeFileIfMissing(join(tokenDirectory, file.name), file.content);
+    }
+    await writeFileIfMissing(themePath, `import { darkColorTheme, darkShadowTheme, lightColorTheme, lightShadowTheme } from "./themes.stylex";\nimport * as stylex from "@stylexjs/stylex";\n\nexport type NooehColorMode = "light" | "dark";\n\nconst themeClassNames = [\n  stylex.props(lightColorTheme, lightShadowTheme).className,\n  stylex.props(darkColorTheme, darkShadowTheme).className,\n]\n  .filter(Boolean)\n  .flatMap((className) => className.split(" "));\n\nexport function applyNooehTheme(mode: NooehColorMode = "light") {\n  const colorTheme = mode === "dark" ? darkColorTheme : lightColorTheme;\n  const shadowTheme = mode === "dark" ? darkShadowTheme : lightShadowTheme;\n  const themeClassName = stylex.props(colorTheme, shadowTheme).className ?? "";\n  const root = document.documentElement;\n\n  root.dataset.theme = mode;\n  root.classList.remove(...themeClassNames);\n  root.classList.add(...themeClassName.split(" ").filter(Boolean));\n}\n`);
+    return { entryPath, stylePath, themePath };
+}
+async function writeFileIfMissing(path, source) {
+    try {
+        await access(path);
+    }
+    catch {
+        await writeFile(path, source, "utf8");
+    }
+}
+export async function init(projectDirectory, options) {
+    if ((await hasConfig(projectDirectory)) && !options.force) {
+        throw new Error("nooeh.json already exists. Use --force to create it again.");
+    }
+    const isInteractive = process.stdin.isTTY && process.stdout.isTTY && !options.defaults;
+    const readline = isInteractive
+        ? createInterface({ input: process.stdin, output: process.stdout })
+        : null;
+    try {
+        if (options.framework && options.framework !== "vite") {
+            throw new Error(`Unsupported framework: ${options.framework}. Use vite or omit --framework.`);
+        }
+        const uiAlias = options["ui-alias"] ??
+            (readline
+                ? await ask("Enter the UI alias.", defaultConfig.aliases.ui, readline)
+                : defaultConfig.aliases.ui);
+        const tokens = options.tokens ??
+            (readline
+                ? await ask("Enter the token directory.", defaultConfig.tokens, readline)
+                : defaultConfig.tokens);
+        const tokenDirectory = resolveTokensPath(projectDirectory, tokens);
+        if (!options["skip-dependencies"]) {
+            await installDependencies(projectDirectory, ["@stylexjs/stylex"]);
+            await installDependencies(projectDirectory, ["@stylexjs/unplugin"], true);
+        }
+        if (options.framework === "vite") {
+            await writeViteFiles(projectDirectory, tokenDirectory);
+        }
+        else {
+            const { stylePath, themePath } = await writeNooehFiles(projectDirectory, tokenDirectory);
+            console.log(`Created ${relative(projectDirectory, stylePath)} and ${relative(projectDirectory, themePath)}.`);
+            console.log("Import the CSS and call applyNooehTheme() from your application entry point.");
+        }
+        await writeConfig(projectDirectory, { aliases: { ui: uiAlias }, tokens });
+    }
+    finally {
+        readline?.close();
+    }
+    console.log(`Created configuration: ${configFileName}`);
+}

package/dist/new-component.d.ts

@@ -0,0 +1 @@
+export declare function newComponent(projectDirectory: string, name: string | undefined): Promise<void>;

package/dist/new-component.js

@@ -0,0 +1,42 @@
+import { access, mkdir, writeFile } from "node:fs/promises";
+import { dirname, join, relative, sep } from "node:path";
+import { readConfig, resolveAliasPath, resolveTokensPath } from "./config.js";
+function toPascalCase(name) {
+    return name
+        .split("-")
+        .filter(Boolean)
+        .map((part) => `${part[0]?.toUpperCase()}${part.slice(1)}`)
+        .join("");
+}
+export async function newComponent(projectDirectory, name) {
+    if (!name || !/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(name)) {
+        throw new Error("Enter a component name in kebab-case. For example: status-chip.");
+    }
+    const config = await readConfig(projectDirectory);
+    const uiDirectory = await resolveAliasPath(projectDirectory, config.aliases.ui);
+    const componentName = toPascalCase(name);
+    const componentPath = join(uiDirectory, `${name}.tsx`);
+    const tokenPath = join(resolveTokensPath(projectDirectory, config.tokens), "tokens.stylex.ts");
+    const relativeTokenPath = relative(dirname(componentPath), tokenPath)
+        .replace(/\.ts$/, "")
+        .split(sep)
+        .join("/");
+    const tokenImport = relativeTokenPath.startsWith(".")
+        ? relativeTokenPath
+        : `./${relativeTokenPath}`;
+    const files = [componentPath];
+    for (const file of files) {
+        try {
+            await access(file);
+            throw new Error(`${file} already exists. Existing components will not be overwritten.`);
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !error.message.includes("already exists"))
+                continue;
+            throw error;
+        }
+    }
+    await mkdir(uiDirectory, { recursive: true });
+    await writeFile(componentPath, `import { colorVars, radiusVars, spacingVars } from "${tokenImport}";\nimport * as stylex from "@stylexjs/stylex";\nimport type { ComponentProps } from "react";\n\nconst styles = stylex.create({\n  root: {\n    backgroundColor: colorVars.bgSurface,\n    borderRadius: radiusVars.sm,\n    padding: spacingVars.space3,\n  },\n});\n\nexport type ${componentName}Props = ComponentProps<"div"> & {\n  xstyle?: stylex.StyleXStyles;\n};\n\nexport function ${componentName}({ className, style, xstyle, ...props }: ${componentName}Props) {\n  const stylexProps = stylex.props(styles.root, xstyle);\n\n  return (\n    <div\n      {...props}\n      className={[stylexProps.className, className].filter(Boolean).join(" ")}\n      style={{ ...stylexProps.style, ...style }}\n    />\n  );\n}\n`, { flag: "wx" });
+    console.log(`Created a ${name} component scaffold: ${componentPath}`);
+}

package/dist/registry.d.ts

@@ -0,0 +1,6 @@
+export declare function resolveComponent(name: string): Promise<{
+    components: string[];
+    files: import("@nooeh/registry").RegistryFile[];
+    externalDependencies: string[];
+    primaryExport: string;
+}>;

package/dist/registry.js

@@ -0,0 +1,81 @@
+import { dependencyVersions, getRegistryItem } from "@nooeh/registry";
+export async function resolveComponent(name) {
+    if (URL.canParse(name))
+        return resolveRemoteComponent(name);
+    const components = new Set();
+    const externalDependencies = new Set();
+    const files = new Map();
+    async function visit(componentName) {
+        if (components.has(componentName))
+            return;
+        const item = await getRegistryItem(componentName);
+        components.add(componentName);
+        for (const file of item.files)
+            files.set(file.path, file);
+        for (const dependency of item.dependencies)
+            externalDependencies.add(dependency);
+        for (const dependency of item.registryDependencies) {
+            await visit(dependency);
+        }
+    }
+    await visit(name);
+    return {
+        components: [...components],
+        files: [...files.values()],
+        externalDependencies: [...externalDependencies].map((dependency) => `${dependency}@${dependencyVersions[dependency] ?? "latest"}`),
+        primaryExport: (await getRegistryItem(name)).primaryExport,
+    };
+}
+async function resolveRemoteComponent(url) {
+    const components = new Set();
+    const externalDependencies = new Set();
+    const files = new Map();
+    async function visitLocal(name) {
+        if (components.has(name))
+            return;
+        const item = await getRegistryItem(name);
+        components.add(name);
+        for (const file of item.files)
+            files.set(file.path, file);
+        for (const dependency of item.dependencies)
+            externalDependencies.add(dependency);
+        for (const dependency of item.registryDependencies)
+            await visitLocal(dependency);
+    }
+    async function visitRemote(itemUrl) {
+        const response = await fetch(itemUrl);
+        if (!response.ok)
+            throw new Error(`Could not load the registry: ${response.status}`);
+        const item = (await response.json());
+        if (!Array.isArray(item.files) ||
+            !Array.isArray(item.dependencies) ||
+            !item.files.every((file) => typeof file === "object" &&
+                file !== null &&
+                typeof file.path === "string" &&
+                typeof file.content === "string")) {
+            throw new Error("This is not a valid Nooeh registry item.");
+        }
+        const itemName = item.name ?? itemUrl;
+        if (components.has(itemName))
+            return;
+        components.add(itemName);
+        for (const file of item.files)
+            files.set(file.path, file);
+        for (const dependency of item.dependencies)
+            externalDependencies.add(dependency);
+        for (const dependency of item.registryDependencies ?? []) {
+            if (URL.canParse(dependency))
+                await visitRemote(dependency);
+            else
+                await visitLocal(dependency);
+        }
+        return item.primaryExport ?? item.name ?? "Component";
+    }
+    const primaryExport = (await visitRemote(url)) ?? "Component";
+    return {
+        components: [...components],
+        externalDependencies: [...externalDependencies].map((dependency) => `${dependency}@${dependencyVersions[dependency] ?? "latest"}`),
+        files: [...files.values()],
+        primaryExport,
+    };
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@nooeh/cli",
+  "version": "0.1.0",
+  "private": false,
+  "bin": {
+    "nooeh": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@nooeh/registry": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.1",
+    "typescript": "7.0.2"
+  },
+  "scripts": {
+    "build": "pnpm --filter @nooeh/registry build && tsc -p tsconfig.build.json",
+    "test": "pnpm build && node --experimental-strip-types --test test/*.test.ts",
+    "typecheck": "tsc --noEmit && pnpm build && tsc -p tsconfig.test.json"
+  }
+}