@smoothbricks/cli 0.1.1 → 0.3.0

package/dist/monorepo/tool-validation.js

@@ -0,0 +1,399 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { cliPackageVersion, isSmoothBricksCodebasePackageName } from '../lib/cli-package.js';
+import { getOrCreateRecord, readJsonObject, recordProperty, setStringProperty, writeJsonObject } from '../lib/json.js';
+import { readPackageJsonObject } from '../lib/workspace.js';
+const rootDevDependencies = [
+    { name: '@biomejs/biome', fallbackVersion: '^2.3.5', minimumVersion: '2.3.0', prefix: '^' },
+    { name: '@nx/js', fallbackVersion: '22.0.3', minimumVersion: '22.0.0' },
+    {
+        name: '@smoothbricks/nx-plugin',
+        fallbackVersion: '^0.0.1',
+        minimumVersion: '0.0.1',
+        prefix: '^',
+        useWorkspaceRangeInCodebase: true,
+    },
+    { name: 'eslint', fallbackVersion: '^9.39.1', minimumVersion: '9.39.0', prefix: '^' },
+    {
+        name: 'eslint-stdout',
+        fallbackVersion: '^1.1.1',
+        minimumVersion: '1.1.1',
+        prefix: '^',
+        useWorkspaceRangeInCodebase: true,
+    },
+    { name: 'nx', fallbackVersion: '22.5.4', minimumVersion: '22.5.0' },
+    { name: 'prettier', fallbackVersion: '^3.6.1', minimumVersion: '3.6.0', prefix: '^' },
+    { name: 'typescript', fallbackVersion: '^5.9.3', minimumVersion: '5.9.0', prefix: '^' },
+];
+const cliPackageName = '@smoothbricks/cli';
+const requiredDevenvPackages = ['bun', 'git', 'git-format-staged', 'jq', 'alejandra', 'coreutils', 'gnutar'];
+const allowedNodePackages = ['nodejs_24', 'nodejs_latest'];
+export async function applyToolConfigDefaults(root) {
+    const context = readToolContext(root);
+    await applyRootPackageToolDefaults(root, context);
+    applyToolingPackageDefaults(root, context.policy);
+    applyDevenvPackageDefaults(root);
+}
+export function validateToolConfig(root) {
+    const context = readToolContext(root);
+    return (validateRootDevDependencies(context.policy, context.rootPackage) +
+        validateToolingPackage(root, context.policy) +
+        validateToolingWorkspace(context.rootPackage) +
+        validateDevenvPackages(root));
+}
+export async function applyRootDevDependencyDefaults(root, context) {
+    const pkg = context.rootPackage;
+    if (!pkg) {
+        return;
+    }
+    let changed = false;
+    const devDependencies = getOrCreateRecord(pkg, 'devDependencies');
+    for (const dependency of rootDevDependencies) {
+        const current = devDependencies[dependency.name];
+        if (typeof current !== 'string' || !satisfiesDependencyPolicy(context.policy, current, dependency)) {
+            const version = await resolveDependencyVersion(context.policy, dependency);
+            changed = setStringProperty(devDependencies, dependency.name, version) || changed;
+        }
+    }
+    if (delete devDependencies['@smoothbricks/cli']) {
+        changed = true;
+    }
+    if (changed) {
+        writeJsonObject(join(root, 'package.json'), pkg);
+        console.log('updated        package.json workspace tool dependencies');
+    }
+    else {
+        console.log('unchanged      package.json workspace tool dependencies');
+    }
+}
+async function applyRootPackageToolDefaults(root, context) {
+    const pkg = context.rootPackage;
+    if (!pkg) {
+        return;
+    }
+    let dependencyChanged = false;
+    let workspaceChanged = false;
+    const devDependencies = getOrCreateRecord(pkg, 'devDependencies');
+    for (const dependency of rootDevDependencies) {
+        const current = devDependencies[dependency.name];
+        if (typeof current !== 'string' || !satisfiesDependencyPolicy(context.policy, current, dependency)) {
+            const version = await resolveDependencyVersion(context.policy, dependency);
+            dependencyChanged = setStringProperty(devDependencies, dependency.name, version) || dependencyChanged;
+        }
+    }
+    if (delete devDependencies[cliPackageName]) {
+        dependencyChanged = true;
+    }
+    workspaceChanged = addWorkspacePattern(pkg, 'tooling');
+    if (dependencyChanged || workspaceChanged) {
+        writeJsonObject(join(root, 'package.json'), pkg);
+    }
+    console.log(dependencyChanged
+        ? 'updated        package.json workspace tool dependencies'
+        : 'unchanged      package.json workspace tool dependencies');
+    console.log(workspaceChanged
+        ? 'updated        package.json tooling workspace'
+        : 'unchanged      package.json tooling workspace');
+}
+export function applyToolingPackageDefaults(root, policy) {
+    const path = join(root, 'tooling', 'package.json');
+    const pkg = readJsonObject(path) ?? { name: policy.toolingPackageName, private: true, dependencies: {} };
+    let changed = false;
+    changed = setStringProperty(pkg, 'name', policy.toolingPackageName) || changed;
+    if (pkg.private !== true) {
+        pkg.private = true;
+        changed = true;
+    }
+    const dependencies = getOrCreateRecord(pkg, 'dependencies');
+    changed = setStringProperty(dependencies, cliPackageName, policy.cliDependencyRange) || changed;
+    if (changed || !existsSync(path)) {
+        mkdirSync(dirname(path), { recursive: true });
+        writeJsonObject(path, pkg);
+        console.log('updated        tooling/package.json tooling dependencies');
+    }
+    else {
+        console.log('unchanged      tooling/package.json tooling dependencies');
+    }
+}
+export function applyToolingWorkspaceDefault(root) {
+    const path = join(root, 'package.json');
+    const pkg = readJsonObject(path);
+    if (!pkg) {
+        return;
+    }
+    if (addWorkspacePattern(pkg, 'tooling')) {
+        writeJsonObject(path, pkg);
+        console.log('updated        package.json tooling workspace');
+    }
+    else {
+        console.log('unchanged      package.json tooling workspace');
+    }
+}
+export function applyDevenvPackageDefaults(root) {
+    const path = join(root, 'tooling', 'direnv', 'devenv.nix');
+    if (!existsSync(path)) {
+        return;
+    }
+    let content = readFileSync(path, 'utf8');
+    let changed = false;
+    if (!allowedNodePackages.some((name) => hasNixPackage(content, name))) {
+        const next = addNixPackage(content, 'nodejs_latest', '# Node.js for workspace tooling');
+        changed = next !== content || changed;
+        content = next;
+    }
+    for (const name of requiredDevenvPackages) {
+        if (hasNixPackage(content, name)) {
+            continue;
+        }
+        const next = addNixPackage(content, name, nixPackageComment(name));
+        changed = next !== content || changed;
+        content = next;
+    }
+    if (changed) {
+        writeFileSync(path, content);
+        console.log('updated        tooling/direnv/devenv.nix packages');
+    }
+    else {
+        console.log('unchanged      tooling/direnv/devenv.nix packages');
+    }
+}
+export function validateRootDevDependencies(policy, rootPackage) {
+    const pkg = rootPackage;
+    if (!pkg) {
+        console.error('package.json not found or invalid');
+        return 1;
+    }
+    const devDependencies = recordProperty(pkg, 'devDependencies');
+    let failures = 0;
+    for (const dependency of rootDevDependencies) {
+        const version = devDependencies?.[dependency.name];
+        if (typeof version !== 'string') {
+            console.error(`package.json devDependencies.${dependency.name} must be defined`);
+            failures++;
+        }
+        else if (!satisfiesDependencyPolicy(policy, version, dependency)) {
+            console.error(`package.json devDependencies.${dependency.name} must be ${formatExpectedDependency(policy, dependency)}; found ${version}`);
+            failures++;
+        }
+    }
+    if (typeof devDependencies?.[cliPackageName] === 'string') {
+        console.error(`package.json devDependencies.${cliPackageName} must move to tooling/package.json dependencies`);
+        failures++;
+    }
+    return failures;
+}
+export function validateToolingPackage(root, policy) {
+    const path = join(root, 'tooling', 'package.json');
+    const pkg = readJsonObject(path);
+    if (!pkg) {
+        console.error('tooling/package.json not found or invalid');
+        return 1;
+    }
+    const dependencies = recordProperty(pkg, 'dependencies');
+    let failures = 0;
+    const actualName = typeof pkg.name === 'string' ? pkg.name : null;
+    if (actualName !== policy.toolingPackageName) {
+        console.error(`tooling/package.json name must be ${policy.toolingPackageName}`);
+        failures++;
+    }
+    const actualCliRange = dependencies?.[cliPackageName];
+    if (actualCliRange !== policy.cliDependencyRange) {
+        console.error(`tooling/package.json dependencies.${cliPackageName} must be ${policy.cliDependencyRange}`);
+        failures++;
+    }
+    return failures;
+}
+export function validateToolingWorkspace(rootPackage) {
+    const pkg = rootPackage;
+    if (!pkg) {
+        console.error('package.json not found or invalid');
+        return 1;
+    }
+    if (!hasWorkspacePattern(pkg, 'tooling')) {
+        console.error('package.json workspaces must include tooling so tooling/package.json participates in installs');
+        return 1;
+    }
+    return 0;
+}
+export function validateDevenvPackages(root) {
+    const path = join(root, 'tooling', 'direnv', 'devenv.nix');
+    if (!existsSync(path)) {
+        console.error('tooling/direnv/devenv.nix not found');
+        return 1;
+    }
+    const content = readFileSync(path, 'utf8');
+    let failures = 0;
+    if (!allowedNodePackages.some((name) => hasNixPackage(content, name))) {
+        console.error(`tooling/direnv/devenv.nix packages must include ${allowedNodePackages.join(' or ')}`);
+        failures++;
+    }
+    for (const name of requiredDevenvPackages) {
+        if (!hasNixPackage(content, name)) {
+            console.error(`tooling/direnv/devenv.nix packages must include ${name}`);
+            failures++;
+        }
+    }
+    return failures;
+}
+function addNixPackage(content, name, comment) {
+    const packageLine = `    ${name}${comment ? ` ${comment}` : ''}\n`;
+    if (hasNixPackage(content, name)) {
+        return content;
+    }
+    const packagesStart = content.indexOf('  packages = with pkgs; [');
+    if (packagesStart === -1) {
+        return content;
+    }
+    const insertAt = content.indexOf('\n', packagesStart) + 1;
+    return `${content.slice(0, insertAt)}${packageLine}${content.slice(insertAt)}`;
+}
+function hasNixPackage(content, name) {
+    return new RegExp(`(^|\\s)${escapeRegex(name)}(\\s|#|$)`, 'm').test(content);
+}
+function nixPackageComment(name) {
+    if (name === 'coreutils') {
+        return '# Provides fmt for commit message wrapping';
+    }
+    if (name === 'gnutar') {
+        return '# Tarball inspection for package validation';
+    }
+    if (name === 'git') {
+        return '# Git hooks and repository inspection';
+    }
+    return '';
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function satisfiesDependencyPolicy(policy, version, dependency) {
+    if (workspaceDependencyExpected(policy, dependency)) {
+        return version === 'workspace:*';
+    }
+    if (dependency.minimumVersion === undefined) {
+        return version === dependency.fallbackVersion;
+    }
+    const parsed = parseVersion(version);
+    const minimum = parseVersion(dependency.minimumVersion);
+    if (!parsed || !minimum) {
+        return false;
+    }
+    return compareVersions(parsed, minimum) >= 0;
+}
+function formatExpectedDependency(policy, dependency) {
+    if (workspaceDependencyExpected(policy, dependency)) {
+        return 'workspace:*';
+    }
+    return dependency.minimumVersion ? `>= ${dependency.minimumVersion}` : dependency.fallbackVersion;
+}
+export function readToolContext(root) {
+    const rootPackage = readPackageJsonObject(join(root, 'package.json'));
+    return { rootPackage, policy: toolPolicy(rootPackage) };
+}
+function toolPolicy(rootPackage) {
+    const name = typeof rootPackage?.name === 'string' ? rootPackage.name : null;
+    const isCodebase = isSmoothBricksCodebasePackageName(name ?? undefined);
+    const toolingName = toolingPackageName(name);
+    return {
+        isSmoothBricksCodebase: isCodebase,
+        toolingPackageName: toolingName,
+        cliDependencyRange: isCodebase ? 'workspace:*' : `^${cliPackageVersion}`,
+    };
+}
+function toolingPackageName(rootName) {
+    const name = rootName;
+    const scope = name?.match(/^(@[^/]+)\//)?.[1];
+    return scope ? `${scope}/tooling` : 'tooling';
+}
+function workspaceDependencyExpected(policy, dependency) {
+    return dependency.useWorkspaceRangeInCodebase === true && policy.isSmoothBricksCodebase;
+}
+async function resolveDependencyVersion(policy, dependency) {
+    if (workspaceDependencyExpected(policy, dependency)) {
+        return 'workspace:*';
+    }
+    if (!dependency.minimumVersion) {
+        return dependency.fallbackVersion;
+    }
+    const latest = await fetchLatestPatchVersion(dependency.name, dependency.minimumVersion);
+    return `${dependency.prefix ?? ''}${latest ?? stripRangePrefix(dependency.fallbackVersion)}`;
+}
+async function fetchLatestPatchVersion(packageName, minimumVersion) {
+    const minorRange = sameMajorMinorRange(minimumVersion);
+    const url = `https://registry.npmjs.org/${encodeURIComponent(packageName).replace('%40', '@')}`;
+    const response = await fetch(url, { headers: { accept: 'application/vnd.npm.install-v1+json' } });
+    if (!response.ok) {
+        return null;
+    }
+    const body = await response.json();
+    if (!isRegistryPackument(body)) {
+        return null;
+    }
+    return latestVersionInSameMajorMinor(Object.keys(body.versions), minorRange);
+}
+function sameMajorMinorRange(minimumVersion) {
+    return parseVersion(minimumVersion);
+}
+function parseVersion(version) {
+    const match = /^[~^]?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(version.trim());
+    if (!match?.[1] || !match[2] || !match[3]) {
+        return null;
+    }
+    return { major: Number(match[1]), minor: Number(match[2]), patch: Number(match[3]) };
+}
+function latestVersionInSameMajorMinor(versions, minimum) {
+    if (!minimum) {
+        return null;
+    }
+    let latest = null;
+    for (const raw of versions) {
+        const version = parseVersion(raw);
+        if (!version || version.major !== minimum.major || version.minor !== minimum.minor) {
+            continue;
+        }
+        if (compareVersions(version, minimum) < 0) {
+            continue;
+        }
+        if (!latest || compareVersions(version, latest) > 0) {
+            latest = version;
+        }
+    }
+    return latest ? `${latest.major}.${latest.minor}.${latest.patch}` : null;
+}
+function compareVersions(left, right) {
+    return left.major - right.major || left.minor - right.minor || left.patch - right.patch;
+}
+function isRegistryPackument(value) {
+    return typeof value === 'object' && value !== null && 'versions' in value && isObjectRecord(value.versions);
+}
+function isObjectRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function stripRangePrefix(version) {
+    return version.replace(/^[~^]/, '');
+}
+function addWorkspacePattern(pkg, pattern) {
+    const workspaces = pkg.workspaces;
+    if (Array.isArray(workspaces)) {
+        if (workspaces.includes(pattern)) {
+            return false;
+        }
+        workspaces.push(pattern);
+        return true;
+    }
+    if (isObjectRecord(workspaces) && Array.isArray(workspaces.packages)) {
+        if (workspaces.packages.includes(pattern)) {
+            return false;
+        }
+        workspaces.packages.push(pattern);
+        return true;
+    }
+    pkg.workspaces = ['packages/*', pattern];
+    return true;
+}
+function hasWorkspacePattern(pkg, pattern) {
+    const workspaces = pkg.workspaces;
+    if (Array.isArray(workspaces)) {
+        return workspaces.includes(pattern);
+    }
+    return isObjectRecord(workspaces) && Array.isArray(workspaces.packages) && workspaces.packages.includes(pattern);
+}

package/dist/nx/index.d.ts

@@ -0,0 +1,25 @@
+export interface ProjectTargets {
+    project: string;
+    targets: string[];
+    buildDependsOn?: string[];
+}
+export interface CommandInvocation {
+    command: string;
+    args: string[];
+}
+export declare function nxResetCommand(): CommandInvocation;
+export declare function nxShowProjectCommand(project: string): CommandInvocation;
+export declare function nxCacheDirectories(root: string): string[];
+export declare function targetNamesFromNxProjectJson(value: unknown): string[];
+export declare function buildDependsOnFromNxProjectJson(value: unknown): string[] | undefined;
+export declare function formatProjectTargetLines(projects: ProjectTargets[]): string;
+export declare function projectNamesWithTarget(projects: ProjectTargets[], target: string): string[];
+export declare function projectNamesFromNxShowProjectsOutput(output: string): string[];
+export declare function listTargets(root: string): Promise<void>;
+export declare function listProjects(root: string, options: {
+    withTarget?: string;
+}): Promise<void>;
+export declare function resetCache(root: string): Promise<void>;
+export declare function cleanCache(root: string): Promise<void>;
+export declare function readProjectTargets(root: string): Promise<ProjectTargets[]>;
+//# sourceMappingURL=index.d.ts.map

package/dist/nx/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/nx/index.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,wBAAgB,cAAc,IAAI,iBAAiB,CAElD;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAEvE;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAEzD;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAGrE;AAED,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,GAAG,SAAS,CAOpF;AAED,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,MAAM,CAK3E;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,cAAc,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAK3F;AAED,wBAAgB,oCAAoC,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAsB7E;AAED,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAK7D;AAED,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAQhG;AAED,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAG5D;AAED,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAa5D;AAED,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAGhF"}

package/dist/nx/index.js

@@ -0,0 +1,112 @@
+import { existsSync } from 'node:fs';
+import { lstat, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { $ } from 'bun';
+import { isRecord, recordProperty } from '../lib/json.js';
+import { decode, run } from '../lib/run.js';
+export function nxResetCommand() {
+    return { command: 'nx', args: ['reset'] };
+}
+export function nxShowProjectCommand(project) {
+    return { command: 'nx', args: ['show', 'project', project, '--json'] };
+}
+export function nxCacheDirectories(root) {
+    return [join(root, '.nx/cache'), join(root, '.nx/workspace-data'), join(root, 'node_modules/.cache/nx')];
+}
+export function targetNamesFromNxProjectJson(value) {
+    const targets = isRecord(value) ? recordProperty(value, 'targets') : null;
+    return targets ? Object.keys(targets).sort((a, b) => a.localeCompare(b)) : [];
+}
+export function buildDependsOnFromNxProjectJson(value) {
+    const targets = isRecord(value) ? recordProperty(value, 'targets') : null;
+    const build = targets ? recordProperty(targets, 'build') : null;
+    if (!Array.isArray(build?.dependsOn) || !build.dependsOn.every((entry) => typeof entry === 'string')) {
+        return undefined;
+    }
+    return build.dependsOn;
+}
+export function formatProjectTargetLines(projects) {
+    return projects
+        .flatMap((project) => project.targets.map((target) => `${project.project}:${target}`))
+        .sort((a, b) => a.localeCompare(b))
+        .join('\n');
+}
+export function projectNamesWithTarget(projects, target) {
+    return projects
+        .filter((project) => project.targets.includes(target))
+        .map((project) => project.project)
+        .sort((a, b) => a.localeCompare(b));
+}
+export function projectNamesFromNxShowProjectsOutput(output) {
+    const trimmed = output.trim();
+    if (!trimmed) {
+        return [];
+    }
+    if (trimmed.startsWith('[')) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed) && parsed.every((entry) => typeof entry === 'string')) {
+                return parsed.sort((a, b) => a.localeCompare(b));
+            }
+        }
+        catch {
+            // Fall through to legacy newline parsing for older Nx output shapes.
+        }
+    }
+    return trimmed
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .sort((a, b) => a.localeCompare(b));
+}
+export async function listTargets(root) {
+    const output = formatProjectTargetLines(await readProjectTargets(root));
+    if (output) {
+        console.log(output);
+    }
+}
+export async function listProjects(root, options) {
+    if (!options.withTarget) {
+        throw new Error('smoo nx list-projects requires --with-target <target>');
+    }
+    const projects = projectNamesWithTarget(await readProjectTargets(root), options.withTarget).join('\n');
+    if (projects) {
+        console.log(projects);
+    }
+}
+export async function resetCache(root) {
+    const command = nxResetCommand();
+    await run(command.command, command.args, root);
+}
+export async function cleanCache(root) {
+    for (const path of nxCacheDirectories(root)) {
+        if (!existsSync(path)) {
+            continue;
+        }
+        const stat = await lstat(path);
+        if (!stat.isDirectory() && !stat.isSymbolicLink()) {
+            console.warn(`Skipping non-directory Nx cache path: ${path}`);
+            continue;
+        }
+        await rm(path, { recursive: true, force: true });
+        console.log(`Removed ${path}`);
+    }
+}
+export async function readProjectTargets(root) {
+    const projects = await readNxProjectNames(root);
+    return Promise.all(projects.map((project) => readProjectTarget(root, project)));
+}
+async function readNxProjectNames(root) {
+    const result = await $ `nx show projects`.cwd(root).quiet();
+    return projectNamesFromNxShowProjectsOutput(decode(result.stdout));
+}
+async function readProjectTarget(root, project) {
+    const command = nxShowProjectCommand(project);
+    const result = await $ `${command.command} ${command.args}`.cwd(root).quiet();
+    const parsed = JSON.parse(decode(result.stdout));
+    return {
+        project,
+        targets: targetNamesFromNxProjectJson(parsed),
+        buildDependsOn: buildDependsOnFromNxProjectJson(parsed),
+    };
+}

package/dist/release/bootstrap-npm-packages.d.ts

@@ -0,0 +1,19 @@
+import type { ReleasePackageInfo } from './core.js';
+export declare const NPM_BOOTSTRAP_VERSION = "0.0.0-bootstrap.0";
+export declare const NPM_BOOTSTRAP_DIST_TAG = "bootstrap";
+export interface BootstrapNpmPackagesOptions {
+    dryRun: boolean;
+    skipLogin: boolean;
+    packages: string[];
+    otp?: string;
+}
+export interface BootstrapNpmPackagesShell<Package extends ReleasePackageInfo = ReleasePackageInfo> {
+    listReleasePackages(): Package[];
+    packageExists(name: string): Promise<boolean>;
+    login(): Promise<void>;
+    publishPlaceholder(pkg: Package, env?: Record<string, string>): Promise<void>;
+    promptOtp(packageName: string): Promise<string>;
+    log(message: string): void;
+}
+export declare function bootstrapNpmPackages<Package extends ReleasePackageInfo>(shell: BootstrapNpmPackagesShell<Package>, options: BootstrapNpmPackagesOptions): Promise<Package[]>;
+//# sourceMappingURL=bootstrap-npm-packages.d.ts.map

package/dist/release/bootstrap-npm-packages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap-npm-packages.d.ts","sourceRoot":"","sources":["../../src/release/bootstrap-npm-packages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAEpD,eAAO,MAAM,qBAAqB,sBAAsB,CAAC;AACzD,eAAO,MAAM,sBAAsB,cAAc,CAAC;AAElD,MAAM,WAAW,2BAA2B;IAC1C,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,yBAAyB,CAAC,OAAO,SAAS,kBAAkB,GAAG,kBAAkB;IAChG,mBAAmB,IAAI,OAAO,EAAE,CAAC;IACjC,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9E,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAChD,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,wBAAsB,oBAAoB,CAAC,OAAO,SAAS,kBAAkB,EAC3E,KAAK,EAAE,yBAAyB,CAAC,OAAO,CAAC,EACzC,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,OAAO,EAAE,CAAC,CAuCpB"}

package/dist/release/bootstrap-npm-packages.js

@@ -0,0 +1,58 @@
+export const NPM_BOOTSTRAP_VERSION = '0.0.0-bootstrap.0';
+export const NPM_BOOTSTRAP_DIST_TAG = 'bootstrap';
+export async function bootstrapNpmPackages(shell, options) {
+    const packages = selectedReleasePackages(shell.listReleasePackages(), options.packages);
+    if (packages.length === 0) {
+        throw new Error('No owned release packages found.');
+    }
+    const missing = [];
+    for (const pkg of packages) {
+        if (await shell.packageExists(pkg.name)) {
+            shell.log(`${pkg.name}: already exists on npm; skipping placeholder bootstrap.`);
+        }
+        else {
+            missing.push(pkg);
+        }
+    }
+    if (missing.length === 0) {
+        shell.log('All selected owned release packages already exist on npm.');
+        return [];
+    }
+    shell.log(`Bootstrap npm placeholders (${NPM_BOOTSTRAP_VERSION}, dist-tag ${NPM_BOOTSTRAP_DIST_TAG}): ${missing
+        .map((pkg) => pkg.name)
+        .join(', ')}`);
+    if (options.dryRun) {
+        return missing;
+    }
+    if (!options.skipLogin) {
+        await shell.login();
+    }
+    for (const pkg of missing) {
+        shell.log(`${pkg.name}: publishing npm placeholder.`);
+        const otp = options.otp ?? (await shell.promptOtp(pkg.name));
+        await shell.publishPlaceholder(pkg, { NPM_CONFIG_OTP: otp });
+    }
+    shell.log('Bootstrap complete. Run smoo release trust-publisher before the first CI publish.');
+    return missing;
+}
+function selectedReleasePackages(packages, selections) {
+    if (selections.length === 0) {
+        return packages;
+    }
+    const byName = new Map(packages.map((pkg) => [pkg.name, pkg]));
+    const selected = [];
+    const unknown = [];
+    for (const name of selections) {
+        const pkg = byName.get(name);
+        if (pkg) {
+            selected.push(pkg);
+        }
+        else {
+            unknown.push(name);
+        }
+    }
+    if (unknown.length > 0) {
+        throw new Error(`Unknown owned release package selection: ${unknown.join(', ')}`);
+    }
+    return selected;
+}

package/dist/release/candidates.d.ts

@@ -0,0 +1,11 @@
+import type { ReleasePackageInfo } from './core.js';
+export interface AutoReleaseCandidateShell {
+    gitRefExists(ref: string): Promise<boolean>;
+    packageChangedFilesSince(ref: string, packagePath: string): Promise<string[]>;
+    packageJsonAtRef(ref: string, packagePath: string): Promise<Record<string, unknown> | null>;
+    currentPackageJson(packagePath: string): Promise<Record<string, unknown> | null>;
+    packageBuildInputPatterns(projectName: string, packagePath: string): Promise<string[]>;
+    packageHasHistory(packagePath: string): Promise<boolean>;
+}
+export declare function autoReleaseCandidatePackages<Package extends ReleasePackageInfo>(shell: AutoReleaseCandidateShell, packages: Package[]): Promise<Package[]>;
+//# sourceMappingURL=candidates.d.ts.map

package/dist/release/candidates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"candidates.d.ts","sourceRoot":"","sources":["../../src/release/candidates.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAGpD,MAAM,WAAW,yBAAyB;IACxC,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5C,wBAAwB,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAC9E,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;IAC5F,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;IACjF,yBAAyB,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACvF,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC1D;AAgCD,wBAAsB,4BAA4B,CAAC,OAAO,SAAS,kBAAkB,EACnF,KAAK,EAAE,yBAAyB,EAChC,QAAQ,EAAE,OAAO,EAAE,GAClB,OAAO,CAAC,OAAO,EAAE,CAAC,CAQpB"}