auklet 0.1.4 → 0.1.6

package/dist/cli/main.js

@@ -2,12 +2,15 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { cac } from 'cac';
+import { AukletEnvContext } from '#auklet/env';
 import { createAukletLogger } from '#auklet/logger';
+import { runOwnerCli, runPublishCli } from '#auklet/publish/cli';
 import { runDev } from '#auklet/cli/dev';
+import { runInspect } from '#auklet/cli/inspect';
 import { runBuildCss } from '#auklet/cli/buildCss';
+import { parseDevCommand } from '#auklet/cli/parse/dev';
 import { runBuild, runBuildJs } from '#auklet/cli/build';
-import { runOwner, runPublish } from '#auklet/cli/publish';
-import { runInspect } from '#auklet/cli/inspect';
+import { parseBuildCommand, parseBuildCssCommand, parseBuildJsCommand, } from '#auklet/cli/parse/build';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const getPackageVersion = () => {
     const packageJson = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../package.json'), 'utf8'));
@@ -17,61 +20,199 @@ const runVersion = async () => {
     console.log(getPackageVersion());
     return 0;
 };
-const getCommandArgs = (argv, command) => {
+// Raw argv slicing is intentionally kept in this entry module. Command runners
+// only receive parsed options or command-specific raw subcommand args.
+const getRawCommandArgs = (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) => {
+const runCliCommand = (runner) => {
+    return runner().then((exitCode) => {
         process.exit(exitCode ?? 0);
     });
 };
+const createCommandContext = () => {
+    const cwd = process.cwd();
+    return {
+        cwd,
+        envContext: new AukletEnvContext(cwd),
+    };
+};
+const addBuildOverrideOptions = (command) => {
+    return command
+        .option('--source <dir>', 'Source directory')
+        .option('--output <dir>', 'Output directory')
+        .option('--modules [value]', 'Enable unbundled module output')
+        .option('--no-modules', 'Disable unbundled module output')
+        .option('--build.formats <formats>', 'Comma-separated cjs, esm, and/or iife formats')
+        .option('--build.target <target>', 'JavaScript target passed to tsdown')
+        .option('--build.platform <platform>', 'node, neutral, or browser')
+        .option('--build.tsconfig <file>', 'TypeScript config file');
+};
+const addWorkspaceOptions = (command) => {
+    return command
+        .option('--filter <pattern>', 'Select workspace packages by package name')
+        .option('--workspace', "Alias for --filter '*'")
+        .option('--private [value]', 'Include private workspace packages')
+        .option('--deps [value]', "Include selected packages' workspace dependencies");
+};
+const addPublishOptions = (command) => {
+    return command
+        .option('--filter <pattern>', 'Select workspace packages by package name')
+        .option('--workspace', "Alias for --filter '*'")
+        .option('--version <value>', 'Publish version or version bump')
+        .option('--dry-run [value]', 'Validate without writing git or registry state')
+        .option('--format [value]', 'Enable publish output formatter')
+        .option('--no-format', 'Disable publish output formatter')
+        .option('--git [value]', 'Create release commit and tag')
+        .option('--no-git', 'Skip release commit and tag')
+        .option('--allow-dirty [value]', 'Allow publishing from a dirty worktree')
+        .option('--ignore-scripts [value]', 'Skip publish lifecycle hooks')
+        .option('--otp <code>', 'Forward an npm 2FA one-time password')
+        .option('--token <value>', 'Set NODE_AUTH_TOKEN and NPM_TOKEN for subprocesses');
+};
+const createHelpFormatter = (cli) => {
+    return (sections) => {
+        const command = cli.matchedCommand?.name;
+        return sections.map((section) => {
+            if (section.title !== 'Options')
+                return section;
+            let body = section.body.replace(/\s+\(default: true\)/g, '');
+            if (!command) {
+                body = addHelpOptionLine(body, '  -v, --version  Print auklet version');
+            }
+            if (command === 'publish') {
+                body = addHelpOptionLine(body, '  --version <value>        Publish version or version bump');
+            }
+            if (command === 'inspect') {
+                body = addHelpOptionLine(body, '  --version <value>  Publish version or version bump');
+            }
+            return {
+                ...section,
+                body,
+            };
+        });
+    };
+};
+const addHelpOptionLine = (body, line) => {
+    if (body.includes(line.trimStart().split(/\s+/)[0]))
+        return body;
+    const helpLinePattern = /^  -h, --help/m;
+    if (!helpLinePattern.test(body))
+        return `${body}\n${line}`;
+    return body.replace(helpLinePattern, `${line}\n  -h, --help`);
+};
 async function runCli(argv) {
     const cli = cac('auk');
-    cli
-        .command('build [...args]', 'Build package JavaScript and CSS output')
+    addWorkspaceOptions(addBuildOverrideOptions(cli.command('build [...args]', 'Build package JavaScript and CSS output')))
+        .ignoreOptionDefaultValue()
         .allowUnknownOptions()
-        .action(() => runCliCommand(runBuild, getCommandArgs(argv, 'build')));
-    cli
-        .command('build-js [...args]', 'Build package JavaScript output with tsdown')
+        .action(() => runCliCommand(() => {
+        const context = createCommandContext();
+        return runBuild(parseBuildCommand(getRawCommandArgs(argv, 'build'), context));
+    }));
+    addBuildOverrideOptions(cli.command('build-js [...args]', 'Build package JavaScript output with tsdown'))
+        .ignoreOptionDefaultValue()
         .allowUnknownOptions()
-        .action(() => runCliCommand(runBuildJs, getCommandArgs(argv, 'build-js')));
-    cli
+        .action(() => runCliCommand(() => {
+        const context = createCommandContext();
+        return runBuildJs(parseBuildJsCommand(getRawCommandArgs(argv, 'build-js'), context));
+    }));
+    addBuildOverrideOptions(cli
         .command('build-css [...args]', 'Build package module CSS output')
-        .option('-w, --watch', 'Watch module CSS output')
+        .option('-w, --watch', 'Watch module CSS output'))
+        .ignoreOptionDefaultValue()
         .allowUnknownOptions()
-        .action(() => runCliCommand(runBuildCss, getCommandArgs(argv, 'build-css')));
-    cli
-        .command('dev [...args]', 'Watch package JavaScript and CSS output')
+        .action(() => runCliCommand(() => {
+        const context = createCommandContext();
+        return runBuildCss(parseBuildCssCommand(getRawCommandArgs(argv, 'build-css'), context));
+    }));
+    addWorkspaceOptions(addBuildOverrideOptions(cli.command('dev [...args]', 'Watch package JavaScript and CSS output')))
+        .ignoreOptionDefaultValue()
+        .allowUnknownOptions()
+        .action(() => runCliCommand(() => {
+        const context = createCommandContext();
+        return runDev(parseDevCommand(getRawCommandArgs(argv, 'dev'), context));
+    }));
+    addPublishOptions(cli.command('publish [...args]', 'Build and publish package output with pnpm'))
+        .ignoreOptionDefaultValue()
         .allowUnknownOptions()
-        .action(() => runCliCommand(runDev, getCommandArgs(argv, 'dev')));
+        .action(() => runCliCommand(() => runPublishCli(getRawCommandArgs(argv, 'publish'))));
     cli
-        .command('publish [...args]', 'Build and publish package output with pnpm')
+        .command('owner add <user...>', 'Add npm owners to the current package or selected packages')
+        .option('--filter <pattern>', 'Add owners to matching workspace packages')
+        .option('--package <name>', 'Add owners to explicit npm packages')
+        .option('--otp <code>', 'Forward an npm owner-management 2FA code')
+        .ignoreOptionDefaultValue()
         .allowUnknownOptions()
-        .action(() => runCliCommand(runPublish, getCommandArgs(argv, 'publish')));
+        .action(() => runCliCommand(() => runOwnerCli(getRawCommandArgs(argv, 'owner'))));
     cli
         .command('owner [...args]', 'Manage npm package owners with pnpm')
+        .usage('add <user...> [options]')
+        .option('--filter <pattern>', 'Add owners to matching workspace packages')
+        .option('--package <name>', 'Add owners to explicit npm packages')
+        .option('--otp <code>', 'Forward an npm owner-management 2FA code')
+        .ignoreOptionDefaultValue()
+        .allowUnknownOptions()
+        .action(() => runCliCommand(() => runOwnerCli(getRawCommandArgs(argv, 'owner'))));
+    cli
+        .command('inspect publish [...args]', 'Check publish readiness')
+        .option('--filter <pattern>', 'Select workspace packages by package name')
+        .option('--workspace', "Alias for --filter '*'")
+        .option('--version <value>', 'Publish version or version bump')
+        .option('--dry-run [value]', 'Preview dry-run publish behavior')
+        .option('--otp <code>', 'Forward an npm 2FA one-time password')
+        .option('--token <value>', 'Set NODE_AUTH_TOKEN and NPM_TOKEN for subprocesses')
+        .ignoreOptionDefaultValue()
         .allowUnknownOptions()
-        .action(() => runCliCommand(runOwner, getCommandArgs(argv, 'owner')));
+        .action(() => runCliCommand(() => runInspect(getRawCommandArgs(argv, 'inspect'))));
+    cli
+        .command('inspect pack [...args]', 'Check package entry and export files')
+        .option('--filter <pattern>', 'Select workspace packages by package name')
+        .ignoreOptionDefaultValue()
+        .allowUnknownOptions()
+        .action(() => runCliCommand(() => runInspect(getRawCommandArgs(argv, 'inspect'))));
+    addBuildOverrideOptions(cli.command('inspect css [...args]', 'Explain CSS output plans'))
+        .ignoreOptionDefaultValue()
+        .allowUnknownOptions()
+        .action(() => runCliCommand(() => runInspect(getRawCommandArgs(argv, 'inspect'))));
     cli
         .command('inspect [...args]', 'Inspect auklet plans without side effects')
+        .usage('<publish|pack|css> [...args]')
+        .option('--filter <pattern>', 'Select workspace packages by package name')
+        .option('--workspace', "Alias for --filter '*'")
+        .option('--version <value>', 'Publish version or version bump')
+        .option('--dry-run [value]', 'Preview dry-run publish behavior')
+        .option('--otp <code>', 'Forward an npm 2FA one-time password')
+        .option('--token <value>', 'Set publish auth token')
+        .option('--source <dir>', 'CSS inspect source directory')
+        .option('--output <dir>', 'CSS inspect output directory')
+        .option('--modules [value]', 'Enable CSS inspect module output')
+        .option('--no-modules', 'Disable CSS inspect module output')
+        .ignoreOptionDefaultValue()
         .allowUnknownOptions()
-        .action(() => runCliCommand(runInspect, getCommandArgs(argv, 'inspect')));
+        .action(() => runCliCommand(() => runInspect(getRawCommandArgs(argv, 'inspect'))));
     cli
         .command('version', 'Print auklet version')
-        .action(() => runCliCommand(runVersion, []));
-    cli.option('-v, --version', 'Print auklet version');
-    cli.help();
+        .action(() => runCliCommand(runVersion));
+    cli.command('help', 'Print auklet help').action(() => runCliCommand(async () => {
+        cli.unsetMatchedCommand();
+        cli.outputHelp();
+        return 0;
+    }));
+    cli.help(createHelpFormatter(cli));
     if (argv.length <= 2) {
         cli.outputHelp();
         process.exit(1);
     }
-    cli.parse(argv, { run: false });
-    if (!cli.matchedCommand && cli.options.version) {
+    const rawArgs = argv.slice(2);
+    if (rawArgs.length === 1 &&
+        (rawArgs[0] === '-v' || rawArgs[0] === '--version')) {
         console.log(getPackageVersion());
         process.exit(0);
     }
+    cli.parse(argv, { run: false });
     if (cli.options.help) {
         process.exit(0);
     }

package/dist/cli/parse/build.d.ts

@@ -0,0 +1,63 @@
+import type { AukletEnvContext } from '#auklet/env';
+import type { AukletConfig } from '#auklet/types';
+import type { WorkspaceSelection } from '#auklet/cli/parse/workspace';
+export type BuildCommandOptions = {
+    cwd: string;
+    envContext: AukletEnvContext;
+    workspace: WorkspaceSelection;
+    overrides: AukletConfig;
+    passthroughArgs: Array<string>;
+    workspaceScriptArgs: Array<string>;
+};
+export type BuildJsCommandOptions = {
+    cwd: string;
+    envContext: AukletEnvContext;
+    overrides: AukletConfig;
+    passthroughArgs: Array<string>;
+};
+export type BuildCssCommandOptions = {
+    cwd: string;
+    envContext: AukletEnvContext;
+    overrides: AukletConfig;
+    watch: boolean;
+};
+export declare function parseBuildCommand(args: Array<string>, options: {
+    cwd: string;
+    envContext: AukletEnvContext;
+}): {
+    cwd: string;
+    envContext: AukletEnvContext;
+    workspace: {
+        filters: string[];
+        includeDependencies: boolean;
+        includePrivate: boolean;
+    };
+    overrides: AukletConfig;
+    passthroughArgs: string[];
+    workspaceScriptArgs: string[];
+};
+export declare function parseBuildJsCommand(args: Array<string>, options: {
+    cwd: string;
+    envContext: AukletEnvContext;
+}): {
+    cwd: string;
+    envContext: AukletEnvContext;
+    overrides: AukletConfig;
+    passthroughArgs: string[];
+};
+export declare function parseBuildCssCommand(args: Array<string>, options: {
+    cwd: string;
+    envContext: AukletEnvContext;
+}): {
+    cwd: string;
+    envContext: AukletEnvContext;
+    overrides: AukletConfig;
+    watch: boolean;
+};
+export declare function parseBuildOverrideArgs(args: Array<string>, envContext: AukletEnvContext): {
+    args: string[];
+    config: AukletConfig;
+};
+export declare function createBuildEnv(config: AukletConfig): {
+    AUKLET_CONFIG_OVERRIDES: string;
+} | undefined;

package/dist/cli/{buildArgs.js → parse/build.js}

@@ -1,13 +1,48 @@
 import { hasTsdownConfigArg } from '#auklet/build/runTsdown';
 import { aukletCliConfigOverridesEnv, encodeAukletCliConfigOverrides, } from '#auklet/build/cliOverrides';
-import { resolveCliBoolean, resolveCliValue } from '#auklet/cli/values';
-import { AukletEnvContext } from '#auklet/env';
+import { resolveCliBoolean, resolveCliValue } from '#auklet/cli/parse/values';
+import { readFlagValue, readOptionalFlagValue } from '#auklet/cli/parse/core';
+import { parseWorkspaceSelectionArgs } from '#auklet/cli/parse/workspace';
 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, envContext = new AukletEnvContext(process.cwd())) {
+export function parseBuildCommand(args, options) {
+    const workspaceArgs = parseWorkspaceSelectionArgs(args, options.envContext);
+    const buildArgs = parseBuildOverrideArgs(workspaceArgs.remainingArgs, options.envContext);
+    return {
+        cwd: options.cwd,
+        envContext: options.envContext,
+        workspace: workspaceArgs.workspace,
+        overrides: buildArgs.config,
+        passthroughArgs: buildArgs.args,
+        workspaceScriptArgs: workspaceArgs.remainingArgs,
+    };
+}
+export function parseBuildJsCommand(args, options) {
+    const buildArgs = parseBuildOverrideArgs(args, options.envContext);
+    return {
+        cwd: options.cwd,
+        envContext: options.envContext,
+        overrides: buildArgs.config,
+        passthroughArgs: buildArgs.args,
+    };
+}
+export function parseBuildCssCommand(args, options) {
+    const buildArgs = parseBuildOverrideArgs(args, options.envContext);
+    const remainingArgs = buildArgs.args.filter((arg) => arg !== '--watch' && arg !== '-w');
+    if (remainingArgs.length) {
+        throw new Error(`[build-css] unknown build-css argument: ${remainingArgs[0]}`);
+    }
+    return {
+        cwd: options.cwd,
+        envContext: options.envContext,
+        overrides: buildArgs.config,
+        watch: buildArgs.args.includes('--watch') || buildArgs.args.includes('-w'),
+    };
+}
+export function parseBuildOverrideArgs(args, envContext) {
     const remainingArgs = [];
     const config = {};
     for (let index = 0; index < args.length; index += 1) {
@@ -26,7 +61,7 @@ export function resolveBuildCliArgs(args, envContext = new AukletEnvContext(proc
             continue;
         }
         if (name === '--modules') {
-            const value = getOptionalFlagValue(args, index, inlineValue);
+            const value = readOptionalFlagValue(args, index, inlineValue);
             config.modules =
                 value === undefined
                     ? true
@@ -42,7 +77,12 @@ export function resolveBuildCliArgs(args, envContext = new AukletEnvContext(proc
         if (name === '--build.formats') {
             config.build = {
                 ...config.build,
-                formats: parseBuildFormats(getResolvedFlagValue(args, index, inlineValue, name, envContext)),
+                formats: parseBuildFormats(inlineValue === undefined
+                    ? getResolvedFlagValue(args, index, inlineValue, name, envContext)
+                    : (resolveCliValue(inlineValue, {
+                        label: name,
+                        context: envContext,
+                    }) ?? inlineValue)),
             };
             if (inlineValue === undefined)
                 index += 1;
@@ -92,23 +132,8 @@ export function createBuildEnv(config) {
         [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 getOptionalFlagValue = (args, index, inlineValue) => {
-    if (inlineValue !== undefined)
-        return inlineValue;
-    const value = args[index + 1];
-    if (!value || value.startsWith('--'))
-        return undefined;
-    return value;
-};
 const getResolvedFlagValue = (args, index, inlineValue, flag, envContext) => {
-    return resolveCliValue(getFlagValue(args, index, inlineValue, flag), {
+    return resolveCliValue(readFlagValue(args, index, inlineValue, flag), {
         label: flag,
         context: envContext,
     });
@@ -116,7 +141,7 @@ const getResolvedFlagValue = (args, index, inlineValue, flag, envContext) => {
 const parseBuildFormats = (value) => {
     const formats = value
         .split(',')
-        .map((format) => format.trim())
+        .map((item) => item.trim())
         .filter(Boolean);
     if (!formats.length) {
         throw new Error('--build.formats requires at least one format.');

package/dist/cli/parse/core.d.ts

@@ -0,0 +1,14 @@
+import type { AukletEnvContext } from '#auklet/env';
+export declare function stripArgsSeparator(args: Array<string>): string[];
+export declare function readFlagValue(args: Array<string>, index: number, inlineValue: string | undefined, flag: string): string;
+export declare function readOptionalFlagValue(args: Array<string>, index: number, inlineValue: string | undefined): string | undefined;
+export declare function dedupe<T>(items: Array<T>): T[];
+export declare function stringOption(value: unknown, label: string, envContext: AukletEnvContext): string | undefined;
+export declare function deferredStringOption(value: unknown, label: string): {
+    raw: string;
+    resolve(context: AukletEnvContext): string | undefined;
+} | undefined;
+export declare function booleanOption(value: unknown, label: string, envContext: AukletEnvContext, defaultValue?: boolean): boolean;
+export declare function stringArrayOption(value: unknown, label: string, envContext: AukletEnvContext): string[];
+export declare function validateUnknownFlags(argv: Record<string, unknown>, allowedFlags: Set<string>, scope: string): void;
+export declare function validateNoPrefixedFlags(args: Array<string>, allowedFlags: Set<string>, scope: string): void;

package/dist/cli/parse/core.js

@@ -0,0 +1,68 @@
+import { isArray } from 'aidly';
+import { createDeferredCliValue, resolveCliBoolean, resolveCliValue, } from '#auklet/cli/parse/values';
+export function stripArgsSeparator(args) {
+    return args.filter((arg) => arg !== '--');
+}
+export function readFlagValue(args, index, inlineValue, flag) {
+    const value = inlineValue ?? args[index + 1];
+    if (!value || value.startsWith('--')) {
+        throw new Error(`${flag} requires a value.`);
+    }
+    return value;
+}
+export function readOptionalFlagValue(args, index, inlineValue) {
+    if (inlineValue !== undefined)
+        return inlineValue;
+    const value = args[index + 1];
+    if (!value || value.startsWith('--'))
+        return undefined;
+    return value;
+}
+export function dedupe(items) {
+    return [...new Set(items)];
+}
+export function stringOption(value, label, envContext) {
+    if (value === undefined)
+        return undefined;
+    if (isArray(value))
+        return stringOption(value.at(-1), label, envContext);
+    return resolveCliValue(String(value), { label, context: envContext });
+}
+export function deferredStringOption(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (isArray(value))
+        return deferredStringOption(value.at(-1), label);
+    return createDeferredCliValue(String(value), { label });
+}
+export function booleanOption(value, label, envContext, defaultValue = false) {
+    if (value === undefined)
+        return defaultValue;
+    if (isArray(value)) {
+        return booleanOption(value.at(-1), label, envContext, defaultValue);
+    }
+    if (typeof value === 'boolean')
+        return value;
+    return resolveCliBoolean(String(value), { label, context: envContext });
+}
+export function stringArrayOption(value, label, envContext) {
+    if (value === undefined)
+        return [];
+    const values = isArray(value)
+        ? value.map((item) => stringOption(item, label, envContext)).filter(Boolean)
+        : [stringOption(value, label, envContext)].filter(Boolean);
+    return values.filter((item) => Boolean(item));
+}
+export function validateUnknownFlags(argv, allowedFlags, scope) {
+    for (const flag of Object.keys(argv)) {
+        if (!allowedFlags.has(flag)) {
+            throw new Error(`[${scope}] unknown option: --${flag}`);
+        }
+    }
+}
+export function validateNoPrefixedFlags(args, allowedFlags, scope) {
+    const flag = args.find((arg) => arg.startsWith('--no-') && !allowedFlags.has(arg));
+    if (flag) {
+        throw new Error(`[${scope}] unknown option: ${flag}`);
+    }
+}

package/dist/cli/parse/dev.d.ts

@@ -0,0 +1,18 @@
+import type { AukletEnvContext } from '#auklet/env';
+import type { BuildCommandOptions } from '#auklet/cli/parse/build';
+export type DevCommandOptions = BuildCommandOptions;
+export declare function parseDevCommand(args: Array<string>, options: {
+    cwd: string;
+    envContext: AukletEnvContext;
+}): {
+    cwd: string;
+    envContext: AukletEnvContext;
+    workspace: {
+        filters: string[];
+        includeDependencies: boolean;
+        includePrivate: boolean;
+    };
+    overrides: import("../..").AukletConfig;
+    passthroughArgs: string[];
+    workspaceScriptArgs: string[];
+};

package/dist/cli/parse/dev.js

@@ -0,0 +1,4 @@
+import { parseBuildCommand } from '#auklet/cli/parse/build';
+export function parseDevCommand(args, options) {
+    return parseBuildCommand(args, options);
+}

package/dist/cli/parse/owner.d.ts

@@ -0,0 +1,11 @@
+import type { AukletEnvContext } from '#auklet/env';
+export declare function parseOwnerCommand(args: Array<string>, options: {
+    cwd: string;
+    envContext: AukletEnvContext;
+}): {
+    cwd: string;
+    users: string[];
+    filters: string[];
+    packages: string[];
+    otp: string | undefined;
+};

package/dist/cli/parse/owner.js

@@ -0,0 +1,25 @@
+import minimist from 'minimist';
+import { stringArrayOption, stringOption, stripArgsSeparator, validateNoPrefixedFlags, validateUnknownFlags, } from '#auklet/cli/parse/core';
+const ownerFlags = new Set(['_', 'filter', 'package', 'otp']);
+export function parseOwnerCommand(args, options) {
+    const cliArgs = stripArgsSeparator(args);
+    validateNoPrefixedFlags(cliArgs, new Set(), 'publish');
+    const argv = minimist(cliArgs, {
+        string: ['filter', 'package', 'otp'],
+    });
+    validateUnknownFlags(argv, ownerFlags, 'publish');
+    const [subcommand, ...users] = argv._;
+    if (subcommand !== 'add') {
+        throw new Error('[publish] expected owner command: auk owner add <user...>');
+    }
+    if (!users.length) {
+        throw new Error('[publish] owner add requires at least one user.');
+    }
+    return {
+        cwd: options.cwd,
+        users,
+        filters: stringArrayOption(argv.filter, '--filter', options.envContext),
+        packages: stringArrayOption(argv.package, '--package', options.envContext),
+        otp: stringOption(argv.otp, '--otp', options.envContext),
+    };
+}

package/dist/cli/parse/publish.d.ts

@@ -0,0 +1,19 @@
+import type { AukletEnvContext } from '#auklet/env';
+export declare function parsePublishCommand(args: Array<string>, options: {
+    cwd: string;
+    envContext: AukletEnvContext;
+}): {
+    cwd: string;
+    otp: string | undefined;
+    filters: string[];
+    version: string | undefined;
+    git: boolean;
+    format: boolean;
+    dryRun: boolean;
+    allowDirty: boolean;
+    ignoreScripts: boolean;
+    token: {
+        raw: string;
+        resolve(context: AukletEnvContext): string | undefined;
+    } | undefined;
+};

package/dist/cli/parse/publish.js

@@ -0,0 +1,60 @@
+import minimist from 'minimist';
+import { booleanOption, deferredStringOption, dedupe, stringArrayOption, stringOption, stripArgsSeparator, validateNoPrefixedFlags, validateUnknownFlags, } from '#auklet/cli/parse/core';
+const publishFlags = new Set([
+    '_',
+    'filter',
+    'workspace',
+    'version',
+    'dry-run',
+    'format',
+    'git',
+    'otp',
+    'token',
+    'ignore-scripts',
+    'allow-dirty',
+]);
+export function parsePublishCommand(args, options) {
+    const argv = parsePublishArgs(args);
+    if (argv._.length) {
+        throw new Error(`[publish] unknown publish argument: ${argv._.join(' ')}`);
+    }
+    return {
+        cwd: options.cwd,
+        otp: stringOption(argv.otp, '--otp', options.envContext),
+        filters: resolvePublishFilters(argv, options.envContext),
+        version: stringOption(argv.version, '--version', options.envContext),
+        git: booleanOption(argv.git, '--git', options.envContext, true),
+        format: booleanOption(argv.format, '--format', options.envContext, true),
+        dryRun: booleanOption(argv['dry-run'], '--dry-run', options.envContext),
+        allowDirty: booleanOption(argv['allow-dirty'], '--allow-dirty', options.envContext),
+        ignoreScripts: booleanOption(argv['ignore-scripts'], '--ignore-scripts', options.envContext),
+        token: deferredStringOption(argv.token, '--token'),
+    };
+}
+const parsePublishArgs = (args) => {
+    const cliArgs = stripArgsSeparator(args);
+    validateNoPrefixedFlags(cliArgs, new Set(['--no-format', '--no-git']), 'publish');
+    const argv = minimist(cliArgs, {
+        string: [
+            'filter',
+            'version',
+            'otp',
+            'token',
+            'dry-run',
+            'format',
+            'git',
+            'ignore-scripts',
+            'allow-dirty',
+        ],
+        boolean: ['workspace'],
+    });
+    validateUnknownFlags(argv, publishFlags, 'publish');
+    return argv;
+};
+const resolvePublishFilters = (argv, envContext) => {
+    const filters = stringArrayOption(argv.filter, '--filter', envContext);
+    if (booleanOption(argv.workspace, '--workspace', envContext)) {
+        filters.push('*');
+    }
+    return dedupe(filters);
+};

package/dist/cli/parse/workspace.d.ts

@@ -0,0 +1,14 @@
+import type { AukletEnvContext } from '#auklet/env';
+export type WorkspaceSelection = {
+    filters: Array<string>;
+    includePrivate: boolean;
+    includeDependencies: boolean;
+};
+export declare function parseWorkspaceSelectionArgs(args: Array<string>, envContext: AukletEnvContext): {
+    remainingArgs: string[];
+    workspace: {
+        filters: string[];
+        includeDependencies: boolean;
+        includePrivate: boolean;
+    };
+};