auklet 0.0.19 → 0.0.21

package/bin/entry.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { runAukletCli } from '../dist/index.js';
+
+await runAukletCli();

package/dist/build/bundleConfig.js

@@ -1,3 +1,4 @@
+import { isArray } from 'aidly';
 import { getBundleEntry } from '#auklet/build/tsdown/entries';
 import { getIifeAlwaysBundle, getIifeGlobals, } from '#auklet/build/tsdown/dependencies';
 import { configureTsdown, createCommonConfig, } from '#auklet/build/tsdown/common';
@@ -26,7 +27,7 @@ export function createBundleConfigs(context, formats) {
     let hasDtsConfig = false;
     for (const format of formats) {
         const extnames = formatMap[format];
-        for (const extname of Array.isArray(extnames) ? extnames : [extnames]) {
+        for (const extname of isArray(extnames) ? extnames : [extnames]) {
             const emitDts = !hasDtsConfig;
             outputConfigs.push({ format, extname, dts: emitDts });
             hasDtsConfig ||= emitDts;
@@ -47,7 +48,7 @@ export function createBundleConfigs(context, formats) {
             : undefined;
         return configureTsdown(context, {
             ...createCommonConfig(context, deps),
-            entry: getBundleEntry(context.packageRoot),
+            entry: getBundleEntry(context.packageRoot, context.source),
             format,
             globalName: context.globalName,
             outDir: context.output,

package/dist/build/cliOverrides.d.ts

@@ -0,0 +1,22 @@
+import type { AukletConfig } from '#auklet/types';
+export declare const aukletCliConfigOverridesEnv = "AUKLET_CONFIG_OVERRIDES";
+export declare function encodeAukletCliConfigOverrides(config: AukletConfig): string;
+export declare function readAukletCliConfigOverrides(): AukletConfig;
+export declare function mergeAukletConfigOverrides(config: AukletConfig, overrides: AukletConfig): {
+    build: {
+        formats?: Array<import("#auklet/types").PackageBuildFormat>;
+        target?: import("#auklet/types").PackageBuildTarget;
+        platform?: import("#auklet/types").PackageBuildPlatform;
+        banner?: string;
+        externals?: Array<string>;
+        alias?: Record<string, string>;
+        mainFields?: Array<string>;
+        globals?: Record<string, string>;
+        configureTsdown?: import("#auklet/types").ConfigureTsdown;
+        tsconfig?: string;
+    } | undefined;
+    source?: string;
+    output?: string;
+    modules?: boolean;
+    styles?: import("#auklet/types").StyleOptions;
+};

package/dist/build/cliOverrides.js

@@ -0,0 +1,22 @@
+export const aukletCliConfigOverridesEnv = 'AUKLET_CONFIG_OVERRIDES';
+export function encodeAukletCliConfigOverrides(config) {
+    return JSON.stringify(config);
+}
+export function readAukletCliConfigOverrides() {
+    const rawConfig = process.env[aukletCliConfigOverridesEnv];
+    if (!rawConfig)
+        return {};
+    return JSON.parse(rawConfig);
+}
+export function mergeAukletConfigOverrides(config, overrides) {
+    return {
+        ...config,
+        ...overrides,
+        build: config.build || overrides.build
+            ? {
+                ...config.build,
+                ...overrides.build,
+            }
+            : undefined,
+    };
+}

package/dist/build/moduleConfig.js

@@ -19,7 +19,7 @@ export function createModuleConfigs(context) {
     const commonConfig = createCommonConfig(context, {
         neverBundle: context.packageExternal,
     });
-    const entry = getModuleEntries(context.packageRoot);
+    const entry = getModuleEntries(context.packageRoot, context.source);
     return [
         createModuleConfig(context, commonConfig, entry, 'esm', path.join(context.output, 'es')),
         createModuleConfig(context, commonConfig, entry, 'cjs', path.join(context.output, 'lib')),

package/dist/build/runTsdown.d.ts

@@ -1,5 +1,7 @@
+export declare function hasTsdownConfigArg(args: Array<string>): boolean;
 export type RunTsdownOptions = {
     cwd?: string;
+    env?: Record<string, string>;
 };
 export declare function createTsdownArgs(args: Array<string>): string[];
 export declare function runTsdown(args: Array<string>, options?: RunTsdownOptions): Promise<number>;

package/dist/build/runTsdown.js

@@ -5,16 +5,16 @@ const require = createRequire(import.meta.url);
 const tsdownRunFile = require.resolve('tsdown/run');
 const currentExtension = import.meta.url.endsWith('.ts') ? 'ts' : 'js';
 const defaultConfigFile = fileURLToPath(new URL(`./tsdownConfig.${currentExtension}`, import.meta.url));
-const hasConfigArg = (args) => {
+export function hasTsdownConfigArg(args) {
     return args.some((arg, index) => arg === '--no-config' ||
         arg === '-c' ||
         arg === '--config' ||
         arg.startsWith('--config=') ||
         args[index - 1] === '-c' ||
         args[index - 1] === '--config');
-};
+}
 export function createTsdownArgs(args) {
-    const tsdownArgs = hasConfigArg(args)
+    const tsdownArgs = hasTsdownConfigArg(args)
         ? args
         : ['--config', defaultConfigFile, ...args];
     return [tsdownRunFile, ...tsdownArgs];
@@ -23,6 +23,7 @@ export async function runTsdown(args, options = {}) {
     const tsdownArgs = createTsdownArgs(args);
     const result = await execa(process.execPath, tsdownArgs, {
         cwd: options.cwd ?? process.cwd(),
+        env: options.env,
         stdio: 'inherit',
         reject: false,
     });

package/dist/build/tsdown/common.d.ts

@@ -6,8 +6,8 @@ export declare function createCommonConfig(context: BuildContext, deps: TsdownDe
     clean: false;
     sourcemap: false;
     tsconfig: string;
-    target: NonNullable<import("../../types").PackageBuildTarget | undefined>;
-    platform: NonNullable<import("../../types").PackageBuildPlatform | undefined>;
+    target: NonNullable<import("../..").PackageBuildTarget | undefined>;
+    platform: NonNullable<import("../..").PackageBuildPlatform | undefined>;
     alias: Record<string, string>;
     deps: import("node_modules/tsdown/dist/types-CQaSBA5U.mjs").L;
     define: {

package/dist/build/tsdown/context.d.ts

@@ -1,9 +1,10 @@
 import type { PackageBuildOptions } from '#auklet/types';
 import type { PackageJsonLike } from '#auklet/build/tsdown/types';
-export declare function createBuildContext(packageRoot: string, options: PackageBuildOptions, output: string): {
+export declare function createBuildContext(packageRoot: string, options: PackageBuildOptions, source: string, output: string): {
     pkg: PackageJsonLike;
     banner: string;
     packageRoot: string;
+    source: string;
     output: string;
     runtimeDependencyNames: string[];
     packageExternal: string[];

package/dist/build/tsdown/context.js

@@ -20,7 +20,7 @@ const findWorkspaceTsconfig = (packageRoot) => {
         current = parent;
     }
 };
-export function createBuildContext(packageRoot, options, output) {
+export function createBuildContext(packageRoot, options, source, output) {
     const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
     const banner = options.banner ??
         '/*!\n' +
@@ -31,6 +31,7 @@ export function createBuildContext(packageRoot, options, output) {
         pkg,
         banner,
         packageRoot,
+        source,
         output,
         runtimeDependencyNames: Object.keys(pkg.dependencies ?? {}),
         packageExternal: getPackageExternal(pkg, options),

package/dist/build/tsdown/define.js

@@ -3,11 +3,12 @@ import { normalizeAukletConfig } from '#auklet/config';
 import { createBundleConfigs } from '#auklet/build/bundleConfig';
 import { createModuleConfigs } from '#auklet/build/moduleConfig';
 import { createBuildContext } from '#auklet/build/tsdown/context';
+import { mergeAukletConfigOverrides, readAukletCliConfigOverrides, } from '#auklet/build/cliOverrides';
 export function defineKernelPackageConfigFromOptions(packageRoot = process.cwd(), config = {}) {
     const normalizedConfig = normalizeAukletConfig(config);
     const buildOptions = normalizedConfig.build;
     const formats = buildOptions.formats;
-    const context = createBuildContext(packageRoot, buildOptions, normalizedConfig.output);
+    const context = createBuildContext(packageRoot, buildOptions, normalizedConfig.source, normalizedConfig.output);
     const bundleConfigs = createBundleConfigs(context, formats);
     const moduleConfigs = normalizedConfig.modules
         ? createModuleConfigs(context)
@@ -15,6 +16,6 @@ export function defineKernelPackageConfigFromOptions(packageRoot = process.cwd()
     return [...bundleConfigs, ...moduleConfigs];
 }
 export async function defineKernelPackageConfigFromFile(packageRoot = process.cwd()) {
-    const config = await loadAukletConfig(packageRoot, { cacheBust: true });
+    const config = mergeAukletConfigOverrides(await loadAukletConfig(packageRoot, { cacheBust: true }), readAukletCliConfigOverrides());
     return defineKernelPackageConfigFromOptions(packageRoot, config);
 }

package/dist/build/tsdown/dependencies.js

@@ -1,4 +1,6 @@
 import { parseModuleId } from '#auklet/build/tsdown/parseModuleId';
+import { createScopedAukletLogger } from '#auklet/logger';
+const logger = createScopedAukletLogger('build');
 const getExternal = (names) => {
     const external = new Set();
     for (const name of names) {
@@ -53,7 +55,7 @@ export function getIifeAlwaysBundle(context) {
         catch (error) {
             if (!warnedParseFailures.has(id)) {
                 warnedParseFailures.add(id);
-                console.warn(`[auklet:build] Unable to parse module id for IIFE bundle dependency classification: ${id}`, error);
+                logger.warn(`Unable to parse module id for IIFE bundle dependency classification: ${id}`, error);
             }
         }
         return peerDependencies.has(id) ? false : runtimeDependencies.has(id);

package/dist/build/tsdown/entries.d.ts

@@ -1,6 +1,6 @@
-export declare function getBundleEntry(packageRoot: string): {
+export declare function getBundleEntry(packageRoot: string, source?: string): {
     index: string;
 };
-export declare function getModuleEntries(packageRoot: string): Record<string, string> | {
+export declare function getModuleEntries(packageRoot: string, source?: string): Record<string, string> | {
     index: string;
 };

package/dist/build/tsdown/entries.js

@@ -3,22 +3,22 @@ import path from 'node:path';
 const toPosixPath = (value) => {
     return value.split(path.sep).join('/');
 };
-export function getBundleEntry(packageRoot) {
-    const tsEntry = 'src/index.ts';
-    const tsxEntry = 'src/index.tsx';
+export function getBundleEntry(packageRoot, source = 'src') {
+    const tsEntry = path.join(source, 'index.ts');
+    const tsxEntry = path.join(source, 'index.tsx');
     if (fs.existsSync(path.join(packageRoot, tsEntry))) {
-        return { index: tsEntry };
+        return { index: toPosixPath(tsEntry) };
     }
     if (fs.existsSync(path.join(packageRoot, tsxEntry))) {
-        return { index: tsxEntry };
+        return { index: toPosixPath(tsxEntry) };
     }
-    return { index: tsEntry };
+    return { index: toPosixPath(tsEntry) };
 }
-export function getModuleEntries(packageRoot) {
-    const sourceRoot = path.join(packageRoot, 'src');
+export function getModuleEntries(packageRoot, source = 'src') {
+    const sourceRoot = path.join(packageRoot, source);
     const entries = {};
     if (!fs.existsSync(sourceRoot)) {
-        return getBundleEntry(packageRoot);
+        return getBundleEntry(packageRoot, source);
     }
     const collect = (dir) => {
         const dirEntries = fs
@@ -45,5 +45,5 @@ export function getModuleEntries(packageRoot) {
     collect(sourceRoot);
     return Object.keys(entries).length > 0
         ? entries
-        : getBundleEntry(packageRoot);
+        : getBundleEntry(packageRoot, source);
 }

package/dist/build/tsdown/types.d.ts

@@ -13,6 +13,7 @@ export type PackageJsonLike = {
 export type BuildContext = {
     packageRoot: string;
     tsconfig: string;
+    source: string;
     output: string;
     pkg: PackageJsonLike;
     runtimeDependencyNames: Array<string>;

package/dist/cli/build.d.ts

@@ -0,0 +1,5 @@
+import type { AukletConfig } from '#auklet/types';
+export declare function runBuildJs(args: Array<string>, options?: {
+    config?: AukletConfig;
+}): Promise<number>;
+export declare function runBuild(args: Array<string>): Promise<number>;

package/dist/cli/build.js

@@ -0,0 +1,30 @@
+import { cleanAukletOutputByConfig } from '#auklet/build/cleanOutput';
+import { mergeAukletConfigOverrides } from '#auklet/build/cliOverrides';
+import { runTsdown } from '#auklet/build/runTsdown';
+import { loadAukletConfig } from '#auklet/configLoader';
+import { createBuildEnv, resolveBuildCliArgs } from '#auklet/cli/buildArgs';
+import { runBuildCss } from '#auklet/cli/buildCss';
+import { createAukletLogger } from '#auklet/logger';
+export async function runBuildJs(args, options = {}) {
+    const buildArgs = resolveBuildCliArgs(args);
+    const config = mergeAukletConfigOverrides(options.config ?? {}, buildArgs.config);
+    const logger = createAukletLogger();
+    return logger.group('Build JavaScript', async () => {
+        return runTsdown(buildArgs.args, {
+            cwd: process.cwd(),
+            env: createBuildEnv(config),
+        });
+    });
+}
+export async function runBuild(args) {
+    const buildArgs = resolveBuildCliArgs(args);
+    const aukletConfig = mergeAukletConfigOverrides(await loadAukletConfig(process.cwd()), buildArgs.config);
+    cleanAukletOutputByConfig(process.cwd(), aukletConfig);
+    const jsExitCode = await runBuildJs(buildArgs.args, {
+        config: buildArgs.config,
+    });
+    if (jsExitCode)
+        return jsExitCode;
+    createAukletLogger().newline();
+    return runBuildCss([], { aukletConfig });
+}

package/dist/cli/buildArgs.d.ts

@@ -0,0 +1,8 @@
+import type { AukletConfig } from '#auklet/types';
+export declare function resolveBuildCliArgs(args: Array<string>): {
+    args: string[];
+    config: AukletConfig;
+};
+export declare function createBuildEnv(config: AukletConfig): {
+    AUKLET_CONFIG_OVERRIDES: string;
+} | undefined;

package/dist/cli/buildArgs.js

@@ -0,0 +1,114 @@
+import { hasTsdownConfigArg } from '#auklet/build/runTsdown';
+import { aukletCliConfigOverridesEnv, encodeAukletCliConfigOverrides, } from '#auklet/build/cliOverrides';
+const buildFormats = new Set(['cjs', 'esm', 'iife']);
+const buildPlatforms = new Set(['node', 'neutral', 'browser']);
+const hasAukletConfig = (config) => {
+    return Object.keys(config).length > 0;
+};
+export function resolveBuildCliArgs(args) {
+    const remainingArgs = [];
+    const config = {};
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        const [name, inlineValue] = arg.split('=', 2);
+        if (name === '--source') {
+            config.source = getFlagValue(args, index, inlineValue, name);
+            if (inlineValue === undefined)
+                index += 1;
+            continue;
+        }
+        if (name === '--output') {
+            config.output = getFlagValue(args, index, inlineValue, name);
+            if (inlineValue === undefined)
+                index += 1;
+            continue;
+        }
+        if (name === '--modules') {
+            config.modules = true;
+            continue;
+        }
+        if (name === '--no-modules') {
+            config.modules = false;
+            continue;
+        }
+        if (name === '--build.formats') {
+            config.build = {
+                ...config.build,
+                formats: parseBuildFormats(getFlagValue(args, index, inlineValue, name)),
+            };
+            if (inlineValue === undefined)
+                index += 1;
+            continue;
+        }
+        if (name === '--build.target') {
+            config.build = {
+                ...config.build,
+                target: getFlagValue(args, index, inlineValue, name),
+            };
+            if (inlineValue === undefined)
+                index += 1;
+            continue;
+        }
+        if (name === '--build.platform') {
+            config.build = {
+                ...config.build,
+                platform: parseBuildPlatform(getFlagValue(args, index, inlineValue, name)),
+            };
+            if (inlineValue === undefined)
+                index += 1;
+            continue;
+        }
+        if (name === '--build.tsconfig') {
+            config.build = {
+                ...config.build,
+                tsconfig: getFlagValue(args, index, inlineValue, name),
+            };
+            if (inlineValue === undefined)
+                index += 1;
+            continue;
+        }
+        remainingArgs.push(arg);
+    }
+    if (hasAukletConfig(config) && hasTsdownConfigArg(remainingArgs)) {
+        throw new Error('Auklet build config flags cannot be used with tsdown --config, -c, or --no-config.');
+    }
+    return {
+        args: remainingArgs,
+        config,
+    };
+}
+export function createBuildEnv(config) {
+    if (!hasAukletConfig(config))
+        return undefined;
+    return {
+        [aukletCliConfigOverridesEnv]: encodeAukletCliConfigOverrides(config),
+    };
+}
+const getFlagValue = (args, index, inlineValue, flag) => {
+    const value = inlineValue ?? args[index + 1];
+    if (!value || value.startsWith('--')) {
+        throw new Error(`${flag} requires a value.`);
+    }
+    return value;
+};
+const parseBuildFormats = (value) => {
+    const formats = value
+        .split(',')
+        .map((format) => format.trim())
+        .filter(Boolean);
+    if (!formats.length) {
+        throw new Error('--build.formats requires at least one format.');
+    }
+    for (const format of formats) {
+        if (!buildFormats.has(format)) {
+            throw new Error(`Unknown build format: ${format}`);
+        }
+    }
+    return formats;
+};
+const parseBuildPlatform = (value) => {
+    if (!buildPlatforms.has(value)) {
+        throw new Error(`Unknown build platform: ${value}`);
+    }
+    return value;
+};

package/dist/cli/buildCss.d.ts

@@ -0,0 +1,12 @@
+import { ModuleStyleWatcher } from '#auklet/css/watch/watcher';
+import type { AukletConfig } from '#auklet/types';
+export declare function resolveBuildCssConfig(args: Array<string>, options?: {
+    aukletConfig?: AukletConfig;
+}): Promise<{
+    aukletConfig: AukletConfig;
+    shouldWatch: boolean;
+}>;
+export declare function startBuildCssWatch(aukletConfig: AukletConfig): Promise<ModuleStyleWatcher>;
+export declare function runBuildCss(args: Array<string>, options?: {
+    aukletConfig?: AukletConfig;
+}): Promise<number>;

package/dist/cli/buildCss.js

@@ -0,0 +1,53 @@
+import { createAukletLogger } from '#auklet/logger';
+import { loadAukletConfig } from '#auklet/configLoader';
+import { resolveBuildCliArgs } from '#auklet/cli/buildArgs';
+import { ModuleStyleWatcher } from '#auklet/css/watch/watcher';
+import { ModuleStyleBuilder } from '#auklet/css/production/builder';
+import { mergeAukletConfigOverrides } from '#auklet/build/cliOverrides';
+import { logModuleStyleBuildResult } from '#auklet/css/production/buildReporter';
+export async function resolveBuildCssConfig(args, options = {}) {
+    const buildArgs = resolveBuildCliArgs(args);
+    const shouldWatch = buildArgs.args.includes('--watch') || buildArgs.args.includes('-w');
+    const aukletConfig = options.aukletConfig ??
+        mergeAukletConfigOverrides(await loadAukletConfig(process.cwd(), {
+            cacheBust: shouldWatch,
+        }), buildArgs.config);
+    return {
+        aukletConfig,
+        shouldWatch,
+    };
+}
+export async function startBuildCssWatch(aukletConfig) {
+    const logger = createAukletLogger();
+    return logger.group('Build CSS', async () => {
+        const css = logger.child('css');
+        const watcher = new ModuleStyleWatcher({ aukletConfig });
+        await watcher.watch();
+        css.success('watch mode ready');
+        return watcher;
+    });
+}
+export async function runBuildCss(args, options = {}) {
+    const logger = createAukletLogger();
+    const { aukletConfig, shouldWatch } = await resolveBuildCssConfig(args, options);
+    if (shouldWatch) {
+        const watcher = await startBuildCssWatch(aukletConfig);
+        const close = () => {
+            watcher
+                .close()
+                .catch(console.error)
+                .finally(() => process.exit(0));
+        };
+        process.once('SIGINT', close);
+        process.once('SIGTERM', close);
+        await new Promise(() => { });
+        return 0;
+    }
+    const builder = new ModuleStyleBuilder({ aukletConfig });
+    await logger.group('Build CSS', async () => {
+        const timer = logger.timer();
+        const result = await builder.build();
+        logModuleStyleBuildResult(logger.child('css'), result, timer.elapsed());
+    });
+    return 0;
+}

package/dist/cli/dev.d.ts

@@ -0,0 +1 @@
+export declare function runDev(args: Array<string>): Promise<number>;

package/dist/cli/dev.js

@@ -0,0 +1,39 @@
+import { execa } from 'execa';
+import { createTsdownArgs } from '#auklet/build/runTsdown';
+import { createBuildEnv, resolveBuildCliArgs } from '#auklet/cli/buildArgs';
+import { resolveBuildCssConfig, startBuildCssWatch, } from '#auklet/cli/buildCss';
+export async function runDev(args) {
+    let closed = false;
+    let jsProcess = null;
+    const buildArgs = resolveBuildCliArgs(args);
+    const { aukletConfig } = await resolveBuildCssConfig(['--watch', ...args]);
+    const cssWatcher = await startBuildCssWatch(aukletConfig);
+    const close = async () => {
+        if (closed)
+            return;
+        closed = true;
+        jsProcess?.kill('SIGTERM');
+        await cssWatcher.close();
+    };
+    const closeAndExit = () => {
+        close()
+            .catch(console.error)
+            .finally(() => process.exit(0));
+    };
+    try {
+        jsProcess = execa(process.execPath, createTsdownArgs([...buildArgs.args, '--watch']), {
+            cwd: process.cwd(),
+            env: createBuildEnv(buildArgs.config),
+            stdio: 'inherit',
+            reject: false,
+        });
+        process.once('SIGINT', closeAndExit);
+        process.once('SIGTERM', closeAndExit);
+        return await jsProcess.then((result) => result.exitCode ?? 0);
+    }
+    finally {
+        process.off('SIGINT', closeAndExit);
+        process.off('SIGTERM', closeAndExit);
+        await close();
+    }
+}

package/dist/cli/main.d.ts

@@ -0,0 +1 @@
+export declare function runAukletCli(argv?: string[]): Promise<void>;

package/dist/cli/main.js

@@ -0,0 +1,95 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { cac } from 'cac';
+import { createAukletLogger } from '#auklet/logger';
+import { runDev } from '#auklet/cli/dev';
+import { runBuildCss } from '#auklet/cli/buildCss';
+import { runBuild, runBuildJs } from '#auklet/cli/build';
+import { runOwner, runPublish } from '#auklet/cli/publish';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const getPackageVersion = () => {
+    const packageJson = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../package.json'), 'utf8'));
+    return packageJson.version;
+};
+const runVersion = async () => {
+    console.log(getPackageVersion());
+    return 0;
+};
+const getCommandArgs = (argv, command) => {
+    const rawArgs = argv.slice(2);
+    const commandIndex = rawArgs.indexOf(command);
+    return commandIndex >= 0 ? rawArgs.slice(commandIndex + 1) : [];
+};
+const runCliCommand = (runner, args) => {
+    return runner(args).then((exitCode) => {
+        process.exit(exitCode ?? 0);
+    });
+};
+async function runCli(argv) {
+    const cli = cac('auk');
+    cli
+        .command('build [...args]', 'Build package JavaScript and CSS output')
+        .allowUnknownOptions()
+        .action(() => runCliCommand(runBuild, getCommandArgs(argv, 'build')));
+    cli
+        .command('build-js [...args]', 'Build package JavaScript output with tsdown')
+        .allowUnknownOptions()
+        .action(() => runCliCommand(runBuildJs, getCommandArgs(argv, 'build-js')));
+    cli
+        .command('build-css [...args]', 'Build package module CSS output')
+        .option('-w, --watch', 'Watch module CSS output')
+        .allowUnknownOptions()
+        .action(() => runCliCommand(runBuildCss, getCommandArgs(argv, 'build-css')));
+    cli
+        .command('dev [...args]', 'Watch package JavaScript and CSS output')
+        .allowUnknownOptions()
+        .action(() => runCliCommand(runDev, getCommandArgs(argv, 'dev')));
+    cli
+        .command('publish [...args]', 'Build and publish package output with pnpm')
+        .allowUnknownOptions()
+        .action(() => runCliCommand(runPublish, getCommandArgs(argv, 'publish')));
+    cli
+        .command('owner [...args]', 'Manage npm package owners with pnpm')
+        .allowUnknownOptions()
+        .action(() => runCliCommand(runOwner, getCommandArgs(argv, 'owner')));
+    cli
+        .command('version', 'Print auklet version')
+        .action(() => runCliCommand(runVersion, []));
+    cli.option('-v, --version', 'Print auklet version');
+    cli.help();
+    if (argv.length <= 2) {
+        cli.outputHelp();
+        process.exit(1);
+    }
+    cli.parse(argv, { run: false });
+    if (!cli.matchedCommand && cli.options.version) {
+        console.log(getPackageVersion());
+        process.exit(0);
+    }
+    if (cli.options.help) {
+        process.exit(0);
+    }
+    if (!cli.matchedCommand) {
+        const [command] = argv.slice(2);
+        if (command) {
+            const logger = createAukletLogger({ scope: 'cli' });
+            logger.error(`Unknown auk command: ${command}`);
+        }
+        else {
+            cli.outputHelp();
+        }
+        process.exit(1);
+    }
+    await cli.runMatchedCommand();
+}
+export async function runAukletCli(argv = process.argv) {
+    try {
+        await runCli(argv);
+    }
+    catch (error) {
+        const logger = createAukletLogger({ scope: 'cli' });
+        logger.error(error);
+        process.exit(1);
+    }
+}

package/dist/cli/publish.d.ts

@@ -0,0 +1,2 @@
+export declare function runPublish(args: Array<string>): Promise<number>;
+export declare function runOwner(args: Array<string>): Promise<number>;

package/dist/cli/publish.js

@@ -0,0 +1,9 @@
+import { runOwnerCli, runPublishCli } from '#auklet/publish/cli';
+export async function runPublish(args) {
+    await runPublishCli(args);
+    return 0;
+}
+export async function runOwner(args) {
+    await runOwnerCli(args);
+    return 0;
+}