auklet 0.0.18 → 0.0.20

package/dist/publish/cli.js

@@ -0,0 +1,94 @@
+import minimist from 'minimist';
+import { OwnerRunner } from '#auklet/publish/ownerRunner';
+import { PublishRunner } from '#auklet/publish/publishRunner';
+import { ensurePnpm } from '#auklet/publish/api/pnpmApi';
+const publishFlags = new Set([
+    '_',
+    'filter',
+    'version',
+    'dry-run',
+    'format',
+    'otp',
+    'ignore-scripts',
+    'allow-dirty',
+]);
+const ownerFlags = new Set(['_', 'filter', 'package', 'otp']);
+export async function runPublishCli(args) {
+    const cliArgs = stripLeadingArgsSeparator(args);
+    validateNoPrefixedFlags(cliArgs, new Set(['--no-format']));
+    const argv = minimist(cliArgs, {
+        string: ['filter', 'version', 'otp'],
+        boolean: ['dry-run', 'format', 'ignore-scripts', 'allow-dirty'],
+        default: {
+            format: true,
+        },
+    });
+    validateFlags(argv, publishFlags);
+    if (argv._.length) {
+        throw new Error(`[auklet:publish] unknown publish argument: ${argv._.join(' ')}`);
+    }
+    await ensurePnpm();
+    await new PublishRunner({
+        cwd: process.cwd(),
+        filters: toArray(argv.filter),
+        version: stringOption(argv.version),
+        dryRun: argv['dry-run'] === true,
+        format: argv.format !== false,
+        otp: stringOption(argv.otp),
+        ignoreScripts: argv['ignore-scripts'] === true,
+        allowDirty: argv['allow-dirty'] === true,
+    }).run();
+}
+export async function runOwnerCli(args) {
+    const cliArgs = stripLeadingArgsSeparator(args);
+    validateNoPrefixedFlags(cliArgs, new Set());
+    const argv = minimist(cliArgs, {
+        string: ['filter', 'package', 'otp'],
+    });
+    validateFlags(argv, ownerFlags);
+    const [subcommand, ...users] = argv._;
+    if (subcommand !== 'add') {
+        throw new Error('[auklet:publish] expected owner command: auk owner add <user...>');
+    }
+    if (!users.length) {
+        throw new Error('[auklet:publish] owner add requires at least one user.');
+    }
+    await ensurePnpm();
+    await new OwnerRunner({
+        cwd: process.cwd(),
+        users,
+        filters: toArray(argv.filter),
+        packages: toArray(argv.package),
+        otp: stringOption(argv.otp),
+    }).run();
+}
+const validateFlags = (argv, allowedFlags) => {
+    for (const flag of Object.keys(argv)) {
+        if (!allowedFlags.has(flag)) {
+            throw new Error(`[auklet:publish] unknown option: --${flag}`);
+        }
+    }
+};
+const validateNoPrefixedFlags = (args, allowedFlags) => {
+    const flag = args.find((arg) => arg.startsWith('--no-') && !allowedFlags.has(arg));
+    if (flag) {
+        throw new Error(`[auklet:publish] unknown option: ${flag}`);
+    }
+};
+const stripLeadingArgsSeparator = (args) => {
+    return args.filter((arg) => arg !== '--');
+};
+const toArray = (value) => {
+    if (value === undefined)
+        return [];
+    return Array.isArray(value)
+        ? value.map(String).filter(Boolean)
+        : [String(value)].filter(Boolean);
+};
+const stringOption = (value) => {
+    if (value === undefined)
+        return undefined;
+    if (Array.isArray(value))
+        return String(value.at(-1));
+    return String(value);
+};

package/dist/publish/ownerRunner.d.ts

@@ -0,0 +1,6 @@
+import type { OwnerOptions } from '#auklet/publish/types';
+export declare class OwnerRunner {
+    private readonly options;
+    constructor(options: OwnerOptions);
+    run(): Promise<void>;
+}

package/dist/publish/ownerRunner.js

@@ -0,0 +1,22 @@
+import { runPnpmOwnerAdd } from '#auklet/publish/api/pnpmApi';
+import { resolveOwnerPackageNames } from '#auklet/publish/targetResolver';
+export class OwnerRunner {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async run() {
+        const packageNames = await resolveOwnerPackageNames(this.options);
+        if (!packageNames.length) {
+            throw new Error('[auklet:publish] no owner target package found.');
+        }
+        for (const packageName of packageNames) {
+            for (const user of this.options.users) {
+                await runPnpmOwnerAdd(packageName, user, {
+                    cwd: this.options.cwd,
+                    otp: this.options.otp,
+                });
+            }
+        }
+    }
+}

package/dist/publish/publishRunner.d.ts

@@ -0,0 +1,16 @@
+import type { PublishOptions } from '#auklet/publish/types';
+export declare class PublishRunner {
+    private readonly git;
+    private readonly publisher;
+    private readonly preflight;
+    private readonly versions;
+    private readonly logger;
+    private readonly summaryLogger;
+    private readonly options;
+    constructor(options: PublishOptions);
+    run(): Promise<void>;
+    private preparePlan;
+    private publishWithPlan;
+    private handleFailure;
+    private runAfterPublishSuccess;
+}

package/dist/publish/publishRunner.js

@@ -0,0 +1,108 @@
+import { createAukletLogger, createScopedAukletLogger } from '#auklet/logger';
+import { runPublishHook } from '#auklet/publish/api/publishHookApi';
+import { runPackageBuilds, validateBuildScript, } from '#auklet/publish/runner/packageBuilder';
+import { formatPublishOutputs } from '#auklet/publish/runner/publishOutputFormatter';
+import { resolvePublishPlan } from '#auklet/publish/targetResolver';
+import { PackagePublisher } from '#auklet/publish/runner/packagePublisher';
+import { reportPublishFailure } from '#auklet/publish/runner/publishFailureReporter';
+import { reportPublishSummary } from '#auklet/publish/runner/publishSummaryReporter';
+import { PublishPreflight } from '#auklet/publish/runner/publishPreflight';
+import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
+import { ReleaseGitController } from '#auklet/publish/runner/releaseGitController';
+import { VersionWriter } from '#auklet/publish/runner/versionWriter';
+export class PublishRunner {
+    git;
+    publisher;
+    preflight;
+    versions;
+    logger;
+    summaryLogger;
+    options;
+    constructor(options) {
+        this.options = options;
+        this.logger = createScopedAukletLogger('publish');
+        this.summaryLogger = createAukletLogger();
+        this.git = new ReleaseGitController(this.options, this.logger);
+        this.publisher = new PackagePublisher(this.options);
+        this.preflight = new PublishPreflight(this.options);
+        this.versions = new VersionWriter(this.options, this.logger);
+    }
+    async run() {
+        const plan = await this.preparePlan();
+        let failureHookEnabled = false;
+        try {
+            await runPublishHook({ status: 'beforeBuild', plan });
+            failureHookEnabled = true;
+            this.versions.writeBeforeBuild(plan);
+            await runPackageBuilds(plan.targets, this.logger);
+            await runPublishHook({ status: 'afterBuild', plan });
+            await formatPublishOutputs(plan.targets, this.options.format);
+            await runPublishHook({ status: 'beforePublish', plan });
+            await this.publishWithPlan(plan);
+        }
+        catch (error) {
+            if (!failureHookEnabled) {
+                reportPublishSummary(this.summaryLogger, {
+                    plan,
+                    status: 'failure',
+                    error,
+                });
+                throw error;
+            }
+            await this.handleFailure(plan, error);
+        }
+        await this.runAfterPublishSuccess(plan);
+    }
+    async preparePlan() {
+        const plan = await resolvePublishPlan(this.options, this.logger);
+        validateBuildScript(plan.targets);
+        await this.git.checkBeforePublish(plan);
+        this.versions.logDryRunPlan(plan);
+        return plan;
+    }
+    async publishWithPlan(plan) {
+        if (plan.dryRun) {
+            await this.preflight.run(plan);
+            return;
+        }
+        await this.preflight.run(plan);
+        await this.git.commitAndTag(plan);
+        await this.publisher.run(plan);
+    }
+    async handleFailure(plan, error) {
+        const failedTarget = error instanceof PublishTargetError ? error.target : undefined;
+        try {
+            await runPublishHook({
+                status: 'afterPublish',
+                plan,
+                result: 'failure',
+                failedTarget,
+                error: error instanceof PublishTargetError ? error.originalError : error,
+            });
+        }
+        catch (hookError) {
+            this.logger.error?.(hookError);
+        }
+        if (error instanceof PublishTargetError) {
+            reportPublishFailure(error, plan.version, this.logger);
+        }
+        reportPublishSummary(this.summaryLogger, {
+            plan,
+            status: 'failure',
+            error,
+        });
+        this.versions.logWrittenVersionFailure(plan);
+        throw error;
+    }
+    async runAfterPublishSuccess(plan) {
+        await runPublishHook({
+            status: 'afterPublish',
+            plan,
+            result: 'success',
+        });
+        reportPublishSummary(this.summaryLogger, {
+            plan,
+            status: 'success',
+        });
+    }
+}

package/dist/publish/runner/packageBuilder.d.ts

@@ -0,0 +1,4 @@
+import type { PublishTarget } from '#auklet/publish/types';
+import type { AukletLogger } from '#auklet/logger';
+export declare function validateBuildScript(targets: Array<PublishTarget>): void;
+export declare function runPackageBuilds(targets: Array<PublishTarget>, logger: AukletLogger): Promise<void>;

package/dist/publish/runner/packageBuilder.js

@@ -0,0 +1,15 @@
+import { runPnpmBuild } from '#auklet/publish/api/pnpmApi';
+export function validateBuildScript(targets) {
+    for (const target of targets) {
+        const buildScript = target.packageJson.scripts?.build;
+        if (typeof buildScript !== 'string' || !buildScript) {
+            throw new Error(`[auklet:publish] package ${target.packageName} must define package.json#scripts.build before publishing.`);
+        }
+    }
+}
+export async function runPackageBuilds(targets, logger) {
+    for (const target of targets) {
+        logger.step('build ', logger.package(target.packageName));
+        await runPnpmBuild(target.packageRoot);
+    }
+}

package/dist/publish/runner/packagePublisher.d.ts

@@ -0,0 +1,7 @@
+import type { PublishOptions, PublishPlan } from '#auklet/publish/types';
+export declare class PackagePublisher {
+    private readonly options;
+    private readonly pnpm;
+    constructor(options: PublishOptions);
+    run(plan: PublishPlan): Promise<void>;
+}

package/dist/publish/runner/packagePublisher.js

@@ -0,0 +1,21 @@
+import { PnpmPublishApi } from '#auklet/publish/api/pnpmPublishApi';
+import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
+export class PackagePublisher {
+    options;
+    pnpm = new PnpmPublishApi();
+    constructor(options) {
+        this.options = options;
+    }
+    async run(plan) {
+        const publishedTargets = [];
+        for (const target of plan.targets) {
+            try {
+                await this.pnpm.publish(target, this.options);
+                publishedTargets.push(target);
+            }
+            catch (error) {
+                throw new PublishTargetError(target, 'publish', error, publishedTargets);
+            }
+        }
+    }
+}

package/dist/publish/runner/publishFailureReporter.d.ts

@@ -0,0 +1,3 @@
+import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
+import type { AukletLogger } from '#auklet/logger';
+export declare function reportPublishFailure(error: PublishTargetError, version: string, logger: AukletLogger): void;

package/dist/publish/runner/publishFailureReporter.js

@@ -0,0 +1,14 @@
+export function reportPublishFailure(error, version, logger) {
+    if (error.phase === 'publish' && error.publishedTargets.length) {
+        logger.error('partial publish detected');
+        logger.error('published packages:');
+        for (const target of error.publishedTargets) {
+            logger.error(formatPublishedTarget(logger, target.packageName, version));
+        }
+    }
+    logger.error('failed package:');
+    logger.error(formatPublishedTarget(logger, error.target.packageName, version));
+}
+const formatPublishedTarget = (logger, packageName, version) => {
+    return ['- ', logger.package(packageName), '@', logger.version(version)];
+};

package/dist/publish/runner/publishOutputFormatter.d.ts

@@ -0,0 +1,2 @@
+import type { PublishTarget } from '#auklet/publish/types';
+export declare function formatPublishOutputs(targets: Array<PublishTarget>, enabled: boolean): Promise<void>;

package/dist/publish/runner/publishOutputFormatter.js

@@ -0,0 +1,83 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import prettier from 'prettier';
+const supportedExtensions = new Set([
+    '.js',
+    '.ts',
+    '.tsx',
+    '.css',
+    '.json',
+    '.yaml',
+    '.yml',
+]);
+export async function formatPublishOutputs(targets, enabled) {
+    if (!enabled)
+        return;
+    for (const target of targets) {
+        const files = collectPublishFiles(target);
+        for (const file of files) {
+            await formatFile(file);
+        }
+    }
+}
+const collectPublishFiles = (target) => {
+    const patterns = target.packageJson.files ?? [];
+    const includes = patterns.filter((item) => !item.startsWith('!'));
+    const excludes = patterns
+        .filter((item) => item.startsWith('!'))
+        .map((item) => item.slice(1));
+    const files = new Set();
+    for (const include of includes) {
+        const absolutePath = path.resolve(target.packageRoot, include);
+        if (!fs.existsSync(absolutePath))
+            continue;
+        for (const file of walkFiles(absolutePath)) {
+            if (isExcluded(target.packageRoot, file, excludes))
+                continue;
+            if (!isSupportedStyleFile(file))
+                continue;
+            files.add(file);
+        }
+    }
+    return [...files].sort();
+};
+const walkFiles = (absolutePath) => {
+    const stat = fs.statSync(absolutePath);
+    if (stat.isFile())
+        return [absolutePath];
+    if (!stat.isDirectory())
+        return [];
+    const files = [];
+    for (const entry of fs.readdirSync(absolutePath)) {
+        files.push(...walkFiles(path.join(absolutePath, entry)));
+    }
+    return files;
+};
+const isExcluded = (packageRoot, file, excludes) => {
+    const relativePath = path
+        .relative(packageRoot, file)
+        .split(path.sep)
+        .join('/');
+    return excludes.some((exclude) => {
+        const normalized = exclude.replace(/\\/g, '/').replace(/\/$/, '');
+        return (relativePath === normalized || relativePath.startsWith(`${normalized}/`));
+    });
+};
+const isSupportedStyleFile = (file) => {
+    if (file.endsWith('.d.ts'))
+        return true;
+    return supportedExtensions.has(path.extname(file));
+};
+const formatFile = async (file) => {
+    const source = fs.readFileSync(file, 'utf8');
+    let formatted;
+    try {
+        formatted = await prettier.format(source, { filepath: file });
+    }
+    catch {
+        return;
+    }
+    if (formatted !== source) {
+        fs.writeFileSync(file, formatted);
+    }
+};

package/dist/publish/runner/publishPreflight.d.ts

@@ -0,0 +1,8 @@
+import type { PublishOptions, PublishPlan } from '#auklet/publish/types';
+export declare class PublishPreflight {
+    private readonly options;
+    private readonly pnpm;
+    constructor(options: PublishOptions);
+    run(plan: PublishPlan): Promise<void>;
+    private verifyPnpmPublishDryRun;
+}

package/dist/publish/runner/publishPreflight.js

@@ -0,0 +1,26 @@
+import { PnpmPublishApi } from '#auklet/publish/api/pnpmPublishApi';
+import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
+export class PublishPreflight {
+    options;
+    pnpm = new PnpmPublishApi();
+    constructor(options) {
+        this.options = options;
+    }
+    async run(plan) {
+        await this.verifyPnpmPublishDryRun(plan);
+    }
+    async verifyPnpmPublishDryRun(plan) {
+        const options = {
+            ...this.options,
+            dryRun: true,
+        };
+        for (const target of plan.targets) {
+            try {
+                await this.pnpm.publish(target, options);
+            }
+            catch (error) {
+                throw new PublishTargetError(target, 'preflight', error, []);
+            }
+        }
+    }
+}

package/dist/publish/runner/publishSummaryReporter.d.ts

@@ -0,0 +1,10 @@
+import type { AukletLogger } from '#auklet/logger';
+import type { PublishPlan } from '#auklet/publish/types';
+type PublishSummaryStatus = 'success' | 'failure';
+type PublishSummaryOptions = {
+    plan: PublishPlan;
+    status: PublishSummaryStatus;
+    error?: unknown;
+};
+export declare function reportPublishSummary(logger: AukletLogger, options: PublishSummaryOptions): void;
+export {};

package/dist/publish/runner/publishSummaryReporter.js

@@ -0,0 +1,81 @@
+import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
+export function reportPublishSummary(logger, options) {
+    const publishError = options.error instanceof PublishTargetError ? options.error : undefined;
+    const failedTarget = publishError?.target;
+    const publishedTargets = publishError?.publishedTargets ?? [];
+    const publishedTargetRoots = new Set(publishedTargets.map((target) => getTargetKey(target)));
+    const publishedCount = options.status === 'success' && !options.plan.dryRun
+        ? options.plan.targets.length
+        : publishedTargets.length;
+    logger.newline();
+    logger.raw(logger.colors.gray('-'.repeat(56)));
+    logger.newline();
+    logger.result({
+        title: logger.colors.bold(getSummaryTitle(options.status, options.plan)),
+        status: options.status === 'success' ? 'success' : 'error',
+        body: getSummaryBody(options.status, options.plan, failedTarget),
+        details: {
+            mode: options.plan.dryRun ? 'dry-run' : 'publish',
+            packages: String(options.plan.targets.length),
+            version: logger.version(options.plan.version),
+            published: String(publishedCount),
+        },
+    });
+    logger.tasks({
+        tasks: getVersionChangeTasks(logger, {
+            targets: options.plan.targets,
+            status: options.status,
+            dryRun: options.plan.dryRun,
+            failedTarget,
+            publishedTargetRoots,
+        }),
+    });
+    logger.newline();
+}
+const getSummaryTitle = (status, plan) => {
+    if (status === 'failure')
+        return 'Publish failed';
+    return plan.dryRun ? 'Publish dry-run complete' : 'Publish complete';
+};
+const getSummaryBody = (status, plan, failedTarget) => {
+    if (status === 'success') {
+        return [
+            plan.dryRun
+                ? 'Preflight completed without publishing packages.'
+                : 'All selected packages were published.',
+        ];
+    }
+    if (failedTarget) {
+        return [['Failed at ', failedTarget.packageName, '. Check logs above.']];
+    }
+    return ['Publish stopped before package publishing completed.'];
+};
+const getVersionChangeTasks = (logger, options) => {
+    return options.targets.map((target) => ({
+        title: [
+            logger.package(target.packageName),
+            ' ',
+            ...formatVersionChange(logger, target.version, target.publishVersion),
+        ],
+        status: getVersionChangeTaskStatus(target, options),
+    }));
+};
+const getVersionChangeTaskStatus = (target, options) => {
+    if (options.dryRun)
+        return 'skipped';
+    if (options.status === 'success')
+        return 'success';
+    if (options.failedTarget &&
+        getTargetKey(target) === getTargetKey(options.failedTarget)) {
+        return 'error';
+    }
+    if (options.publishedTargetRoots.has(getTargetKey(target)))
+        return 'success';
+    return 'skipped';
+};
+const getTargetKey = (target) => {
+    return `${target.packageRoot}:${target.packageName}`;
+};
+const formatVersionChange = (logger, from, to) => {
+    return [logger.version(from), logger.colors.gray(' -> '), logger.version(to)];
+};

package/dist/publish/runner/publishTargetError.d.ts

@@ -0,0 +1,9 @@
+import type { PublishTarget } from '#auklet/publish/types';
+export type PublishPhase = 'preflight' | 'publish';
+export declare class PublishTargetError extends Error {
+    readonly target: PublishTarget;
+    readonly phase: PublishPhase;
+    readonly originalError: unknown;
+    readonly publishedTargets: Array<PublishTarget>;
+    constructor(target: PublishTarget, phase: PublishPhase, originalError: unknown, publishedTargets: Array<PublishTarget>);
+}

package/dist/publish/runner/publishTargetError.js

@@ -0,0 +1,14 @@
+import path from 'node:path';
+export class PublishTargetError extends Error {
+    target;
+    phase;
+    originalError;
+    publishedTargets;
+    constructor(target, phase, originalError, publishedTargets) {
+        super(`[auklet:publish] ${phase} failed for ${target.packageName} at ${path.relative(process.cwd(), target.packageRoot) || target.packageRoot}.`);
+        this.target = target;
+        this.phase = phase;
+        this.originalError = originalError;
+        this.publishedTargets = publishedTargets;
+    }
+}

package/dist/publish/runner/releaseGitController.d.ts

@@ -0,0 +1,10 @@
+import type { PublishOptions, PublishPlan } from '#auklet/publish/types';
+import type { AukletLogger } from '#auklet/logger';
+export declare class ReleaseGitController {
+    private readonly options;
+    private readonly logger;
+    constructor(options: PublishOptions, logger: AukletLogger);
+    checkBeforePublish(plan: PublishPlan): Promise<void>;
+    commitAndTag(plan: PublishPlan): Promise<void>;
+    private warnOnce;
+}

package/dist/publish/runner/releaseGitController.js

@@ -0,0 +1,41 @@
+import { commitRelease, createVersionTag, ensureGitClean, hasGitChanges, isGitRepository, } from '#auklet/publish/api/gitApi';
+export class ReleaseGitController {
+    options;
+    logger;
+    constructor(options, logger) {
+        this.options = options;
+        this.logger = logger;
+    }
+    async checkBeforePublish(plan) {
+        const git = await isGitRepository(plan.root);
+        if (plan.dryRun || !git)
+            return;
+        if (this.options.allowDirty) {
+            this.warnOnce('--allow-dirty enabled, skipping git clean check, commit, and tag.');
+            return;
+        }
+        await ensureGitClean(plan.root);
+    }
+    async commitAndTag(plan) {
+        const git = await isGitRepository(plan.root);
+        if (git && this.options.allowDirty) {
+            this.warnOnce('--allow-dirty enabled, skipping git commit and tag.');
+            return;
+        }
+        if (!git) {
+            this.warnOnce('git repository not found, skipping commit and tag.');
+            return;
+        }
+        const changed = await hasGitChanges(plan.root);
+        if (changed) {
+            if (!this.options.version) {
+                throw new Error('[auklet:publish] build or format changed files. Commit changes before publishing without --version.');
+            }
+            await commitRelease(plan.root, plan.version);
+        }
+        await createVersionTag(plan.root, plan.version, this.logger);
+    }
+    warnOnce(content) {
+        this.logger.warnOnce(content);
+    }
+}

package/dist/publish/runner/versionWriter.d.ts

@@ -0,0 +1,13 @@
+import type { PublishOptions, PublishPlan } from '#auklet/publish/types';
+import type { AukletLogger } from '#auklet/logger';
+export declare class VersionWriter {
+    private readonly options;
+    private readonly logger;
+    constructor(options: PublishOptions, logger: AukletLogger);
+    writeBeforeBuild(plan: PublishPlan): void;
+    logDryRunPlan(plan: PublishPlan): void;
+    logWrittenVersionFailure(plan: PublishPlan): void;
+    private writeVersions;
+    private formatPackage;
+    private formatVersionChange;
+}