auklet 0.1.5 → 0.1.7

package/README.md

@@ -48,6 +48,7 @@ Build and dev flags:
 | `--filter <pattern>`          | `build`, `dev`                                         | Select workspace packages by package name.         |
 | `--workspace`                 | `build`, `dev`                                         | Alias for `--filter '*'`.                          |
 | `--deps`                      | `build`, `dev`                                         | Include selected packages' workspace dependencies. |
+| `--private`                   | `build`, `dev`                                         | Include private workspace packages.                |
 
 Notes:
 
@@ -57,6 +58,8 @@ Notes:
 - Workspace `build` runs each target package's own `build` script.
 - Workspace `dev` runs each target package's own `dev` script. Packages without
   a `dev` script fail fast.
+- Workspace `build` and `dev` skip private packages by default. Use `--private`
+  to include them.
 
 ### Publish
 

package/dist/cli/build.js

@@ -6,7 +6,7 @@ import { loadAukletConfig } from '#auklet/configLoader';
 import { createBuildEnv } from '#auklet/cli/parse/build';
 import { runBuildCss } from '#auklet/cli/buildCss';
 import { createAukletLogger } from '#auklet/logger';
-import { getWorkspacePackageScript, resolveWorkspaceBuildTargets, } from '#auklet/cli/buildWorkspace';
+import { getWorkspacePackageScript, resolveWorkspaceScriptTargets, } from '#auklet/cli/workspaceScripts';
 const workspaceBuildEnv = 'AUKLET_WORKSPACE_BUILD';
 export async function runBuildJs(options) {
     return options.envContext.run(async () => {
@@ -33,6 +33,7 @@ export async function runBuild(options) {
                 envContext: options.envContext,
                 filters: options.workspace.filters,
                 includeDependencies: options.workspace.includeDependencies,
+                includePrivate: options.workspace.includePrivate,
             });
         }
         if (options.workspace.includeDependencies) {
@@ -47,8 +48,11 @@ export async function runBuild(options) {
     });
 }
 const runWorkspaceBuild = async (args, options) => {
-    const targets = await resolveWorkspaceBuildTargets(options.cwd, options.filters, options.envContext, {
+    const targets = await resolveWorkspaceScriptTargets(options.cwd, options.filters, options.envContext, {
+        scope: 'build',
+        emptyTargetMessage: '[build] no buildable workspace package found.',
         includeDependencies: options.includeDependencies,
+        includePrivate: options.includePrivate,
     });
     const logger = createAukletLogger();
     for (const target of targets) {

package/dist/cli/dev.js

@@ -2,7 +2,7 @@ import { execa } from 'execa';
 import { createTsdownArgs } from '#auklet/build/runTsdown';
 import { createBuildEnv } from '#auklet/cli/parse/build';
 import { resolveBuildCssConfig, startBuildCssWatch, } from '#auklet/cli/buildCss';
-import { getWorkspacePackageScript, resolveWorkspaceBuildTargets, } from '#auklet/cli/buildWorkspace';
+import { getWorkspacePackageScript, resolveWorkspaceScriptTargets, } from '#auklet/cli/workspaceScripts';
 const workspaceDevEnv = 'AUKLET_WORKSPACE_DEV';
 export async function runDev(options) {
     return options.envContext.run(async () => {
@@ -16,6 +16,7 @@ export async function runDev(options) {
                 workspaceScriptArgs: options.workspaceScriptArgs,
                 filters: options.workspace.filters,
                 includeDependencies: options.workspace.includeDependencies,
+                includePrivate: options.workspace.includePrivate,
             });
         }
         if (options.workspace.includeDependencies) {
@@ -57,8 +58,11 @@ const runDevWithEnv = async (options) => {
 const runWorkspaceDev = async (options) => {
     let closed = false;
     const handles = [];
-    const targets = await resolveWorkspaceBuildTargets(options.cwd, options.filters, options.envContext, {
+    const targets = await resolveWorkspaceScriptTargets(options.cwd, options.filters, options.envContext, {
+        scope: 'dev',
+        emptyTargetMessage: '[dev] no dev workspace package found.',
         includeDependencies: options.includeDependencies,
+        includePrivate: options.includePrivate,
     });
     const close = async () => {
         if (closed)

package/dist/cli/help.d.ts

@@ -0,0 +1,29 @@
+import type { CAC, Command } from 'cac';
+type HelpOption = readonly [flags: string, description: string];
+export declare const buildOverrideOptions: [string, string][];
+export declare const workspaceOptions: [string, string][];
+export declare const publishOptions: [string, string][];
+export declare const ownerOptions: [string, string][];
+export declare const inspectPublishOptions: [string, string][];
+export declare const inspectPackOptions: [string, string][];
+export declare const inspectCssOptions: [string, string][];
+export declare const inspectOptions: [string, string][];
+export declare const commandHelpOptions: {
+    buildOverrides: [string, string][];
+    inspect: [string, string][];
+    inspectCss: [string, string][];
+    inspectPack: [string, string][];
+    inspectPublish: [string, string][];
+    owner: [string, string][];
+    publish: [string, string][];
+    workspace: [string, string][];
+};
+export declare function addCommandOptions(command: Command, options: ReadonlyArray<HelpOption>): Command;
+export declare function createHelpFormatter(cli: CAC): (sections: Array<{
+    title?: string;
+    body: string;
+}>) => {
+    title?: string;
+    body: string;
+}[];
+export {};

package/dist/cli/help.js

@@ -0,0 +1,109 @@
+export const buildOverrideOptions = [
+    ['--source <dir>', 'Source directory'],
+    ['--output <dir>', 'Output directory'],
+    ['--modules [value]', 'Enable unbundled module output'],
+    ['--no-modules', 'Disable unbundled module output'],
+    [
+        '--build.formats <formats>',
+        'Comma-separated cjs, esm, and/or iife formats',
+    ],
+    ['--build.target <target>', 'JavaScript target passed to tsdown'],
+    ['--build.platform <platform>', 'node, neutral, or browser'],
+    ['--build.tsconfig <file>', 'TypeScript config file'],
+];
+export const workspaceOptions = [
+    ['--filter <pattern>', 'Select workspace packages by package name'],
+    ['--workspace', "Alias for --filter '*'"],
+    ['--private [value]', 'Include private workspace packages'],
+    ['--deps [value]', "Include selected packages' workspace dependencies"],
+];
+export const publishOptions = [
+    ['--filter <pattern>', 'Select workspace packages by package name'],
+    ['--workspace', "Alias for --filter '*'"],
+    ['--version <value>', 'Publish version or version bump'],
+    ['--dry-run [value]', 'Validate without writing git or registry state'],
+    ['--format [value]', 'Enable publish output formatter'],
+    ['--no-format', 'Disable publish output formatter'],
+    ['--git [value]', 'Create release commit and tag'],
+    ['--no-git', 'Skip release commit and tag'],
+    ['--allow-dirty [value]', 'Allow publishing from a dirty worktree'],
+    ['--ignore-scripts [value]', 'Skip publish lifecycle hooks'],
+    ['--otp <code>', 'Forward an npm 2FA one-time password'],
+    ['--token <value>', 'Set NODE_AUTH_TOKEN and NPM_TOKEN for subprocesses'],
+];
+export const ownerOptions = [
+    ['--filter <pattern>', 'Add owners to matching workspace packages'],
+    ['--package <name>', 'Add owners to explicit npm packages'],
+    ['--otp <code>', 'Forward an npm owner-management 2FA code'],
+];
+export const inspectPublishOptions = [
+    ['--filter <pattern>', 'Select workspace packages by package name'],
+    ['--workspace', "Alias for --filter '*'"],
+    ['--version <value>', 'Publish version or version bump'],
+    ['--dry-run [value]', 'Preview dry-run publish behavior'],
+    ['--otp <code>', 'Forward an npm 2FA one-time password'],
+    ['--token <value>', 'Set NODE_AUTH_TOKEN and NPM_TOKEN for subprocesses'],
+];
+export const inspectPackOptions = [
+    ['--filter <pattern>', 'Select workspace packages by package name'],
+];
+export const inspectCssOptions = [
+    ['--source <dir>', 'CSS inspect source directory'],
+    ['--output <dir>', 'CSS inspect output directory'],
+    ['--modules [value]', 'Enable CSS inspect module output'],
+    ['--no-modules', 'Disable CSS inspect module output'],
+];
+export const inspectOptions = [
+    ...inspectPublishOptions,
+    ...inspectPackOptions,
+    ...inspectCssOptions,
+].filter((option, index, options) => {
+    // First matching flag wins; keep shared inspect flag descriptions aligned.
+    return options.findIndex(([flags]) => flags === option[0]) === index;
+});
+export const commandHelpOptions = {
+    buildOverrides: buildOverrideOptions,
+    inspect: inspectOptions,
+    inspectCss: inspectCssOptions,
+    inspectPack: inspectPackOptions,
+    inspectPublish: inspectPublishOptions,
+    owner: ownerOptions,
+    publish: publishOptions,
+    workspace: workspaceOptions,
+};
+export function addCommandOptions(command, options) {
+    return options.reduce((currentCommand, [flags, description]) => currentCommand.option(flags, description), command);
+}
+export function createHelpFormatter(cli) {
+    return (sections) => {
+        const command = cli.matchedCommand?.name;
+        return sections.map((section) => {
+            if (section.title !== 'Options')
+                return section;
+            // CAC hides duplicate --version entries, so command-level version flags
+            // are patched back into help output here.
+            let body = section.body.replace(/\s+\(default: true\)/g, '');
+            if (!command) {
+                body = addHelpOptionLine(body, '--version', '  -v, --version  Print auklet version');
+            }
+            if (command === 'publish') {
+                body = addHelpOptionLine(body, '--version', '  --version <value>         Publish version or version bump');
+            }
+            if (command === 'inspect') {
+                body = addHelpOptionLine(body, '--version', '  --version <value>   Publish version or version bump');
+            }
+            return {
+                ...section,
+                body,
+            };
+        });
+    };
+}
+const addHelpOptionLine = (body, key, line) => {
+    if (body.includes(key))
+        return body;
+    const helpLinePattern = /^  -h, --help/m;
+    if (!helpLinePattern.test(body))
+        return `${body}\n${line}`;
+    return body.replace(helpLinePattern, `${line}\n  -h, --help`);
+};

package/dist/cli/main.js

@@ -2,15 +2,16 @@ 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 { runInspect } from '#auklet/cli/inspect';
-import { runOwnerCli, runPublishCli } from '#auklet/publish/cli';
-import { AukletEnvContext } from '#auklet/env';
+import { addCommandOptions, commandHelpOptions, createHelpFormatter, } from '#auklet/cli/help';
 import { parseBuildCommand, parseBuildCssCommand, parseBuildJsCommand, } from '#auklet/cli/parse/build';
-import { parseDevCommand } from '#auklet/cli/parse/dev';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const getPackageVersion = () => {
     const packageJson = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../package.json'), 'utf8'));
@@ -41,61 +42,88 @@ const createCommandContext = () => {
 };
 async function runCli(argv) {
     const cli = cac('auk');
-    cli
-        .command('build [...args]', 'Build package JavaScript and CSS output')
+    addCommandOptions(addCommandOptions(cli.command('build [...args]', 'Build package JavaScript and CSS output'), commandHelpOptions.buildOverrides), commandHelpOptions.workspace)
+        .ignoreOptionDefaultValue()
         .allowUnknownOptions()
         .action(() => runCliCommand(() => {
         const context = createCommandContext();
         return runBuild(parseBuildCommand(getRawCommandArgs(argv, 'build'), context));
     }));
-    cli
-        .command('build-js [...args]', 'Build package JavaScript output with tsdown')
+    addCommandOptions(cli.command('build-js [...args]', 'Build package JavaScript output with tsdown'), commandHelpOptions.buildOverrides)
+        .ignoreOptionDefaultValue()
         .allowUnknownOptions()
         .action(() => runCliCommand(() => {
         const context = createCommandContext();
         return runBuildJs(parseBuildJsCommand(getRawCommandArgs(argv, 'build-js'), context));
     }));
-    cli
+    addCommandOptions(cli
         .command('build-css [...args]', 'Build package module CSS output')
-        .option('-w, --watch', 'Watch module CSS output')
+        .option('-w, --watch', 'Watch module CSS output'), commandHelpOptions.buildOverrides)
+        .ignoreOptionDefaultValue()
         .allowUnknownOptions()
         .action(() => runCliCommand(() => {
         const context = createCommandContext();
         return runBuildCss(parseBuildCssCommand(getRawCommandArgs(argv, 'build-css'), context));
     }));
-    cli
-        .command('dev [...args]', 'Watch package JavaScript and CSS output')
+    addCommandOptions(addCommandOptions(cli.command('dev [...args]', 'Watch package JavaScript and CSS output'), commandHelpOptions.buildOverrides), commandHelpOptions.workspace)
+        .ignoreOptionDefaultValue()
         .allowUnknownOptions()
         .action(() => runCliCommand(() => {
         const context = createCommandContext();
         return runDev(parseDevCommand(getRawCommandArgs(argv, 'dev'), context));
     }));
-    cli
-        .command('publish [...args]', 'Build and publish package output with pnpm')
+    addCommandOptions(cli.command('publish [...args]', 'Build and publish package output with pnpm'), commandHelpOptions.publish)
+        .ignoreOptionDefaultValue()
         .allowUnknownOptions()
         .action(() => runCliCommand(() => runPublishCli(getRawCommandArgs(argv, 'publish'))));
-    cli
+    addCommandOptions(cli.command('owner add <user...>', 'Add npm owners to the current package or selected packages'), commandHelpOptions.owner)
+        .ignoreOptionDefaultValue()
+        .allowUnknownOptions()
+        .action(() => runCliCommand(() => runOwnerCli(getRawCommandArgs(argv, 'owner'))));
+    addCommandOptions(cli
         .command('owner [...args]', 'Manage npm package owners with pnpm')
+        .usage('add <user...> [options]'), commandHelpOptions.owner)
+        .ignoreOptionDefaultValue()
         .allowUnknownOptions()
         .action(() => runCliCommand(() => runOwnerCli(getRawCommandArgs(argv, 'owner'))));
-    cli
+    addCommandOptions(cli.command('inspect publish [...args]', 'Check publish readiness'), commandHelpOptions.inspectPublish)
+        .ignoreOptionDefaultValue()
+        .allowUnknownOptions()
+        .action(() => runCliCommand(() => runInspect(getRawCommandArgs(argv, 'inspect'))));
+    addCommandOptions(cli.command('inspect pack [...args]', 'Check package entry and export files'), commandHelpOptions.inspectPack)
+        .ignoreOptionDefaultValue()
+        .allowUnknownOptions()
+        .action(() => runCliCommand(() => runInspect(getRawCommandArgs(argv, 'inspect'))));
+    addCommandOptions(cli.command('inspect css [...args]', 'Explain CSS output plans'), commandHelpOptions.inspectCss)
+        .ignoreOptionDefaultValue()
+        .allowUnknownOptions()
+        .action(() => runCliCommand(() => runInspect(getRawCommandArgs(argv, 'inspect'))));
+    addCommandOptions(cli
         .command('inspect [...args]', 'Inspect auklet plans without side effects')
+        .usage('<publish|pack|css> [...args]'), commandHelpOptions.inspect)
+        .ignoreOptionDefaultValue()
         .allowUnknownOptions()
         .action(() => runCliCommand(() => runInspect(getRawCommandArgs(argv, 'inspect'))));
     cli
         .command('version', 'Print auklet version')
         .action(() => runCliCommand(runVersion));
-    cli.option('-v, --version', 'Print auklet version');
-    cli.help();
+    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

@@ -30,6 +30,7 @@ export declare function parseBuildCommand(args: Array<string>, options: {
     workspace: {
         filters: string[];
         includeDependencies: boolean;
+        includePrivate: boolean;
     };
     overrides: AukletConfig;
     passthroughArgs: string[];

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

@@ -10,6 +10,7 @@ export declare function parseDevCommand(args: Array<string>, options: {
     workspace: {
         filters: string[];
         includeDependencies: boolean;
+        includePrivate: boolean;
     };
     overrides: import("../..").AukletConfig;
     passthroughArgs: string[];

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

@@ -1,6 +1,7 @@
 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): {
@@ -8,5 +9,6 @@ export declare function parseWorkspaceSelectionArgs(args: Array<string>, envCont
     workspace: {
         filters: string[];
         includeDependencies: boolean;
+        includePrivate: boolean;
     };
 };

package/dist/cli/parse/workspace.js

@@ -1,8 +1,9 @@
 import { resolveCliBoolean, resolveCliValue } from '#auklet/cli/parse/values';
 import { dedupe, readFlagValue, readOptionalFlagValue, } from '#auklet/cli/parse/core';
 export function parseWorkspaceSelectionArgs(args, envContext) {
-    const remainingArgs = [];
     const filters = [];
+    const remainingArgs = [];
+    let includePrivate = false;
     let includeDependencies = false;
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
@@ -24,12 +25,16 @@ export function parseWorkspaceSelectionArgs(args, envContext) {
             continue;
         }
         if (name === '--deps') {
-            const value = readOptionalFlagValue(args, index, inlineValue);
-            includeDependencies =
-                value === undefined
-                    ? true
-                    : resolveCliBoolean(value, { label: name, context: envContext });
-            if (inlineValue === undefined && value !== undefined)
+            const result = readWorkspaceBooleanFlag(args, index, inlineValue, name, envContext);
+            includeDependencies = result.value;
+            if (result.consumedNext)
+                index += 1;
+            continue;
+        }
+        if (name === '--private') {
+            const result = readWorkspaceBooleanFlag(args, index, inlineValue, name, envContext);
+            includePrivate = result.value;
+            if (result.consumedNext)
                 index += 1;
             continue;
         }
@@ -40,6 +45,16 @@ export function parseWorkspaceSelectionArgs(args, envContext) {
         workspace: {
             filters: dedupe(filters),
             includeDependencies,
+            includePrivate,
         },
     };
 }
+const readWorkspaceBooleanFlag = (args, index, inlineValue, name, envContext) => {
+    const value = readOptionalFlagValue(args, index, inlineValue);
+    return {
+        consumedNext: inlineValue === undefined && value !== undefined,
+        value: value === undefined
+            ? true
+            : resolveCliBoolean(value, { label: name, context: envContext }),
+    };
+};

package/dist/cli/{buildWorkspace.d.ts → workspaceScripts.d.ts}

@@ -1,5 +1,5 @@
 import type { AukletEnvContext } from '#auklet/env';
-type WorkspaceBuildPackageJson = {
+type WorkspaceScriptPackageJson = {
     name?: string;
     private?: boolean;
     scripts?: unknown;
@@ -7,17 +7,20 @@ type WorkspaceBuildPackageJson = {
     optionalDependencies?: unknown;
     [key: string]: unknown;
 };
-export type WorkspaceBuildTarget = {
+export type WorkspaceScriptTarget = {
     packageRoot: string;
     packageName: string;
-    packageJson: WorkspaceBuildPackageJson;
+    packageJson: WorkspaceScriptPackageJson;
 };
-export declare function resolveWorkspaceBuildTargets(cwd: string, filters: Array<string>, envContext: AukletEnvContext, options?: {
+export declare function resolveWorkspaceScriptTargets(cwd: string, filters: Array<string>, envContext: AukletEnvContext, options?: {
+    scope?: string;
+    emptyTargetMessage?: string;
+    includePrivate?: boolean;
     includeDependencies?: boolean;
 }): Promise<{
     packageRoot: string;
     packageName: string;
-    packageJson: WorkspaceBuildPackageJson;
+    packageJson: WorkspaceScriptPackageJson;
 }[]>;
-export declare function getWorkspacePackageScript(packageJson: WorkspaceBuildPackageJson, name: string): string | null;
+export declare function getWorkspacePackageScript(packageJson: WorkspaceScriptPackageJson, name: string): string | null;
 export {};

package/dist/cli/{buildWorkspace.js → workspaceScripts.js}

@@ -1,35 +1,35 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { isPlainObject, isString } from 'aidly';
-import { getWorkspaceDependencyNames, resolveWorkspaceTargets, } from '#auklet/workspace/targets';
-export async function resolveWorkspaceBuildTargets(cwd, filters, envContext, options = {}) {
+import { resolveWorkspaceTargets, getWorkspaceDependencyNames, } from '#auklet/workspace/targets';
+export async function resolveWorkspaceScriptTargets(cwd, filters, envContext, options = {}) {
     return resolveWorkspaceTargets({
         cwd,
         filters,
-        env: envContext.normalizedValues,
-        scope: 'build',
-        emptyTargetMessage: '[build] no buildable workspace package found.',
         excludeRoot: true,
-        includePrivate: true,
-        readPackageJson: readBuildPackageJson,
+        env: envContext.normalizedValues,
+        scope: options.scope ?? 'workspace',
+        emptyTargetMessage: options.emptyTargetMessage ?? '[workspace] no workspace package found.',
+        includePrivate: options.includePrivate,
+        readPackageJson: readWorkspaceScriptPackageJson,
+        getDependencies: getWorkspaceScriptDependencies,
+        includeDependencies: options.includeDependencies,
         createTarget: (item, packageJson) => ({
             packageRoot: item.path,
             packageName: item.name,
             packageJson,
         }),
-        getDependencies: getBuildWorkspaceDependencies,
-        includeDependencies: options.includeDependencies,
     });
 }
-const readBuildPackageJson = (packageRoot) => {
+const readWorkspaceScriptPackageJson = (packageRoot) => {
     const file = path.join(packageRoot, 'package.json');
     const packageJson = JSON.parse(fs.readFileSync(file, 'utf8'));
     if (!isPlainObject(packageJson)) {
-        throw new Error(`[build] package.json must be an object at ${file}.`);
+        throw new Error(`[workspace] package.json must be an object at ${file}.`);
     }
     return packageJson;
 };
-const getBuildWorkspaceDependencies = (target) => {
+const getWorkspaceScriptDependencies = (target) => {
     return [
         ...getWorkspaceDependencyNames(target.packageJson.dependencies),
         ...getWorkspaceDependencyNames(target.packageJson.optionalDependencies),

package/dist/publish/targetResolver.js

@@ -24,8 +24,9 @@ export async function resolveOwnerPackageNames(options) {
         });
         return packages.filter((item) => !item.private).map((item) => item.name);
     }
-    if (options.packages.length)
+    if (options.packages.length) {
         return [...new Set(options.packages)];
+    }
     const packageJson = readPackageJson(options.cwd);
     if (packageJson.private) {
         throw new Error('[publish] current package is private.');
@@ -73,6 +74,7 @@ const resolveMonorepoPublishPlan = async (options, runtime, logger) => {
         filters: options.filters,
         getDependencies: getWorkspaceDependencies,
         emptyTargetMessage: '[publish] no publishable package found.',
+        includePrivate: false,
         createTarget: (item, packageJson) => createPublishTarget({
             packageRoot: item.path,
             packageJson,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auklet",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "type": "module",
   "author": "chentao.arthur",
   "description": "Build utilities for TypeScript packages and module CSS output.",