@smoothbricks/cli 0.1.0

package/dist/lib/json.js

@@ -0,0 +1,57 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { hasOwn, hasOwnString, isRecord } from '@smoothbricks/validation';
+export { hasOwn, hasOwnString, isRecord };
+export function stringProperty(record, key) {
+    const value = record[key];
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+export function recordProperty(record, key) {
+    const value = record[key];
+    return isRecord(value) ? value : null;
+}
+export function getOrCreateRecord(record, key) {
+    const value = record[key];
+    if (isRecord(value)) {
+        return value;
+    }
+    const next = {};
+    record[key] = next;
+    return next;
+}
+export function setStringProperty(record, key, value) {
+    if (record[key] === value) {
+        return false;
+    }
+    record[key] = value;
+    return true;
+}
+export function setMissingStringProperty(record, key, value) {
+    if (typeof record[key] === 'string') {
+        return false;
+    }
+    record[key] = value;
+    return true;
+}
+export function requiredJsonObject(path) {
+    const json = readJsonObject(path);
+    if (!json) {
+        throw new Error(`${path} not found or invalid`);
+    }
+    return json;
+}
+export function readJsonObject(path) {
+    const json = readJson(path);
+    return isRecord(json) ? json : null;
+}
+export function writeJsonObject(path, value) {
+    writeFileSync(path, jsonObjectText(value));
+}
+export function jsonObjectText(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+export function readJson(path) {
+    if (!existsSync(path)) {
+        return null;
+    }
+    return JSON.parse(readFileSync(path, 'utf8'));
+}

package/dist/lib/run.d.ts

@@ -0,0 +1,5 @@
+export declare function run(command: string, args: string[], cwd: string, env?: Record<string, string>): Promise<void>;
+export declare function runStatus(command: string, args: string[], cwd: string, quiet?: boolean, env?: Record<string, string>): Promise<number>;
+export declare function findRepoRoot(): Promise<string>;
+export declare function decode(bytes: Uint8Array): string;
+//# sourceMappingURL=run.d.ts.map

package/dist/lib/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/lib/run.ts"],"names":[],"mappings":"AAKA,wBAAsB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAKnH;AAED,wBAAsB,SAAS,CAC7B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,GAAG,EAAE,MAAM,EACX,KAAK,UAAQ,EACb,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3B,OAAO,CAAC,MAAM,CAAC,CAQjB;AAuCD,wBAAsB,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAMpD;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAEhD"}

package/dist/lib/run.js

@@ -0,0 +1,64 @@
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { $ } from 'bun';
+export async function run(command, args, cwd, env) {
+    const status = await runStatus(command, args, cwd, false, env);
+    if (status !== 0) {
+        throw new Error(`${command} ${args.join(' ')} failed with exit code ${status}`);
+    }
+}
+export async function runStatus(command, args, cwd, quiet = false, env) {
+    const invocation = resolveCommandInvocation(cwd, command, args);
+    let shell = $ `${invocation.command} ${invocation.args}`.cwd(cwd).nothrow();
+    if (env) {
+        shell = shell.env(mergeEnv(env));
+    }
+    const result = quiet ? await shell.quiet() : await shell;
+    return result.exitCode;
+}
+function mergeEnv(env) {
+    const merged = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (value !== undefined) {
+            merged[key] = value;
+        }
+    }
+    return { ...merged, ...env };
+}
+function resolveCommandInvocation(root, command, args) {
+    const localCommand = join(root, 'node_modules', '.bin', command);
+    if (existsSync(localCommand)) {
+        return { command: localCommand, args };
+    }
+    const bundledCommand = resolveBundledCommand(command);
+    if (bundledCommand) {
+        return { command: 'bun', args: [bundledCommand, ...args] };
+    }
+    return { command, args };
+}
+function resolveBundledCommand(command) {
+    try {
+        if (command === 'sherif') {
+            return fileURLToPath(import.meta.resolve('sherif'));
+        }
+        if (command === 'attw') {
+            const packageJson = fileURLToPath(import.meta.resolve('@arethetypeswrong/cli/package.json'));
+            return join(dirname(packageJson), 'dist', 'index.js');
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+export async function findRepoRoot() {
+    const result = await $ `git rev-parse --show-toplevel`.cwd(process.cwd()).quiet().nothrow();
+    if (result.exitCode === 0) {
+        return decode(result.stdout).trim();
+    }
+    return process.cwd();
+}
+export function decode(bytes) {
+    return new TextDecoder().decode(bytes);
+}

package/dist/lib/workspace.d.ts

@@ -0,0 +1,23 @@
+export interface PackageInfo {
+    name: string;
+    version: string;
+    private: boolean;
+    tags: string[];
+    path: string;
+    packageJsonPath: string;
+    json: Record<string, unknown>;
+}
+export interface RepositoryInfo {
+    type: string;
+    url: string;
+}
+export declare const workspaceDependencyFields: readonly ["dependencies", "devDependencies", "optionalDependencies"];
+export declare function listPublicPackages(root: string): PackageInfo[];
+export declare function getWorkspacePackages(root: string): PackageInfo[];
+export declare function listPackageJsonRecords(root: string): PackageInfo[];
+export declare function getWorkspacePatterns(root: string): string[];
+export declare function readPackageJson(path: string): PackageInfo | null;
+export declare function getNxTags(pkg: Record<string, unknown>): string[];
+export declare function repositoryInfo(pkg: Record<string, unknown>): RepositoryInfo | null;
+export declare function escapeRegex(value: string): string;
+//# sourceMappingURL=workspace.d.ts.map

package/dist/lib/workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/lib/workspace.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,MAAM,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb;AAED,eAAO,MAAM,yBAAyB,sEAAuE,CAAC;AAE9G,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,EAAE,CAE9D;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,EAAE,CAgChE;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,EAAE,CAMlE;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAa3D;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAgBhE;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,EAAE,CAKhE;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,cAAc,GAAG,IAAI,CAalF;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEjD"}

package/dist/lib/workspace.js

@@ -0,0 +1,101 @@
+import { readdirSync, statSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { hasOwn, hasOwnString, isRecord, readJson, readJsonObject, stringProperty } from './json.js';
+export const workspaceDependencyFields = ['dependencies', 'devDependencies', 'optionalDependencies'];
+export function listPublicPackages(root) {
+    return getWorkspacePackages(root).filter((pkg) => !pkg.private && pkg.tags.includes('npm:public'));
+}
+export function getWorkspacePackages(root) {
+    if (!readPackageJson(join(root, 'package.json'))) {
+        throw new Error('package.json not found or invalid');
+    }
+    const workspacePatterns = getWorkspacePatterns(root);
+    const packages = [];
+    for (const pattern of workspacePatterns) {
+        if (!pattern.endsWith('/*')) {
+            continue;
+        }
+        const parent = join(root, pattern.slice(0, -2));
+        if (!statSync(parent, { throwIfNoEntry: false })?.isDirectory()) {
+            continue;
+        }
+        for (const entry of readdirSync(parent)) {
+            const pkgPath = join(parent, entry, 'package.json');
+            const pkg = readPackageJson(pkgPath);
+            if (!pkg?.name || !pkg.version) {
+                continue;
+            }
+            packages.push({
+                name: pkg.name,
+                version: pkg.version,
+                private: pkg.private,
+                tags: pkg.tags,
+                path: relative(root, dirname(pkgPath)),
+                packageJsonPath: pkg.packageJsonPath,
+                json: pkg.json,
+            });
+        }
+    }
+    return packages.sort((a, b) => a.name.localeCompare(b.name));
+}
+export function listPackageJsonRecords(root) {
+    const rootPackage = readPackageJson(join(root, 'package.json'));
+    if (!rootPackage) {
+        throw new Error('package.json not found or invalid');
+    }
+    return [{ ...rootPackage, path: '.' }, ...getWorkspacePackages(root)];
+}
+export function getWorkspacePatterns(root) {
+    const raw = readJson(join(root, 'package.json'));
+    if (!isRecord(raw) || !hasOwn(raw, 'workspaces')) {
+        return ['packages/*'];
+    }
+    const workspaces = raw.workspaces;
+    if (Array.isArray(workspaces)) {
+        return workspaces.filter((entry) => typeof entry === 'string');
+    }
+    if (isRecord(workspaces) && hasOwn(workspaces, 'packages') && Array.isArray(workspaces.packages)) {
+        return workspaces.packages.filter((entry) => typeof entry === 'string');
+    }
+    return ['packages/*'];
+}
+export function readPackageJson(path) {
+    const parsed = readJsonObject(path);
+    if (!isRecord(parsed) || !hasOwnString(parsed, 'name') || !hasOwnString(parsed, 'version')) {
+        return null;
+    }
+    const privateValue = hasOwn(parsed, 'private') && typeof parsed.private === 'boolean' ? parsed.private : false;
+    const tags = getNxTags(parsed);
+    return {
+        name: parsed.name,
+        version: parsed.version,
+        private: privateValue,
+        tags,
+        path: dirname(path),
+        packageJsonPath: path,
+        json: parsed,
+    };
+}
+export function getNxTags(pkg) {
+    if (!hasOwn(pkg, 'nx') || !isRecord(pkg.nx) || !hasOwn(pkg.nx, 'tags') || !Array.isArray(pkg.nx.tags)) {
+        return [];
+    }
+    return pkg.nx.tags.filter((tag) => typeof tag === 'string');
+}
+export function repositoryInfo(pkg) {
+    const repository = pkg.repository;
+    if (typeof repository === 'string') {
+        return { type: 'git', url: repository };
+    }
+    if (!isRecord(repository)) {
+        return null;
+    }
+    const url = stringProperty(repository, 'url');
+    if (!url) {
+        return null;
+    }
+    return { type: stringProperty(repository, 'type') ?? 'git', url };
+}
+export function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/monorepo/commit-msg.d.ts

@@ -0,0 +1,2 @@
+export declare function validateCommitMessage(message: string): string | null;
+//# sourceMappingURL=commit-msg.d.ts.map

package/dist/monorepo/commit-msg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit-msg.d.ts","sourceRoot":"","sources":["../../src/monorepo/commit-msg.ts"],"names":[],"mappings":"AAcA,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAoBpE"}

package/dist/monorepo/commit-msg.js

@@ -0,0 +1,34 @@
+const validCommitTypes = new Set([
+    'build',
+    'chore',
+    'ci',
+    'docs',
+    'feat',
+    'fix',
+    'perf',
+    'refactor',
+    'revert',
+    'style',
+    'test',
+]);
+export function validateCommitMessage(message) {
+    const subject = message.split('\n', 1)[0]?.trim() ?? '';
+    if (!subject) {
+        return 'Commit message subject is empty.';
+    }
+    if (/^(Merge|Revert ")/.test(subject) || /^(fixup|squash)! /.test(subject)) {
+        return null;
+    }
+    const match = /^(?<type>[a-z]+)(\([a-z0-9._/-]+\))?(?<breaking>!)?: .+$/.exec(subject);
+    const type = match?.groups?.type;
+    if (type && validCommitTypes.has(type)) {
+        return null;
+    }
+    return `Invalid conventional commit subject: ${subject}
+
+Expected examples:
+  feat(statebus-core): add optimistic transactions
+  fix(money): round negative amounts consistently
+  chore(release): publish 1.2.3
+  feat!: remove deprecated API`;
+}

package/dist/monorepo/git-config.d.ts

@@ -0,0 +1,2 @@
+export declare function applyWorkspaceGitConfig(root: string): Promise<void>;
+//# sourceMappingURL=git-config.d.ts.map

package/dist/monorepo/git-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-config.d.ts","sourceRoot":"","sources":["../../src/monorepo/git-config.ts"],"names":[],"mappings":"AAKA,wBAAsB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAYzE"}

package/dist/monorepo/git-config.js

@@ -0,0 +1,37 @@
+import { existsSync, mkdirSync, readlinkSync, rmSync, symlinkSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { $ } from 'bun';
+import { decode } from '../lib/run.js';
+export async function applyWorkspaceGitConfig(root) {
+    const gitDirResult = await $ `git rev-parse --git-dir`.cwd(root).quiet().nothrow();
+    if (gitDirResult.exitCode !== 0) {
+        throw new Error('Not in a git repository');
+    }
+    const gitDir = resolve(root, decode(gitDirResult.stdout).trim());
+    const tooling = join(root, 'tooling');
+    await $ `git config --local include.path ${join(tooling, 'workspace.gitconfig')}`.cwd(root);
+    linkHook(gitDir, tooling, 'pre-commit');
+    linkHook(gitDir, tooling, 'commit-msg');
+}
+function linkHook(gitDir, tooling, name) {
+    const source = join(tooling, 'git-hooks', `${name}.sh`);
+    if (!existsSync(source)) {
+        throw new Error(`Missing ${name} hook source: ${source}`);
+    }
+    const target = join(gitDir, 'hooks', name);
+    if (readLinkOrNull(target) === source) {
+        return;
+    }
+    console.log(`[!] Linking ${name} hook in ${gitDir}`);
+    mkdirSync(dirname(target), { recursive: true });
+    rmSync(target, { force: true });
+    symlinkSync(source, target);
+}
+function readLinkOrNull(path) {
+    try {
+        return readlinkSync(path);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/monorepo/index.d.ts

@@ -0,0 +1,19 @@
+import { applyWorkspaceGitConfig } from './git-config.js';
+import { syncBunLockfileVersions } from './lockfile.js';
+export interface InitOptions {
+    runtimeOnly?: boolean;
+    syncRuntime?: boolean;
+}
+export interface ValidateOptions {
+    failFast?: boolean;
+}
+export declare function initMonorepo(root: string, options: InitOptions): Promise<void>;
+export declare function validateMonorepo(root: string, options?: ValidateOptions): Promise<void>;
+export declare function updateManagedFiles(root: string): void;
+export declare function checkManagedFiles(root: string): void;
+export declare function diffManagedFiles(root: string): void;
+export declare function validateCommitMessageFile(path: string | undefined): void;
+export declare function listPublicProjects(root: string): string;
+export declare function validatePublicPackageTags(root: string): void;
+export { applyWorkspaceGitConfig, syncBunLockfileVersions };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/monorepo/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAMxD,MAAM,WAAW,WAAW;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAQpF;AAED,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAOjG;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAErD;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAMpD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAEnD;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CASxE;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIvD;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAI5D;AAED,OAAO,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/monorepo/index.js

@@ -0,0 +1,59 @@
+import { readFileSync } from 'node:fs';
+import { listPublicPackages } from '../lib/workspace.js';
+import { validateCommitMessage } from './commit-msg.js';
+import { applyWorkspaceGitConfig } from './git-config.js';
+import { syncBunLockfileVersions } from './lockfile.js';
+import { applyManagedFiles, printResults } from './managed-files.js';
+import { validatePublicTags } from './package-policy.js';
+import { runInitPacks, runValidatePacks } from './packs/index.js';
+import { syncRootRuntimeVersions } from './runtime.js';
+export async function initMonorepo(root, options) {
+    if (options.runtimeOnly) {
+        await syncRootRuntimeVersions(root);
+        return;
+    }
+    printResults(applyManagedFiles(root, 'update'));
+    await runInitPacks({ root, syncRuntime: process.env.DEVENV_ROOT !== undefined || options.syncRuntime === true });
+}
+export async function validateMonorepo(root, options = {}) {
+    const failures = await runValidatePacks({ root, syncRuntime: false }, options);
+    if (failures > 0) {
+        throw new Error(`Monorepo validation failed with ${failures} problem(s).`);
+    }
+    console.log('\n== summary ==');
+    console.log('Monorepo configuration is valid.');
+}
+export function updateManagedFiles(root) {
+    printResults(applyManagedFiles(root, 'update'));
+}
+export function checkManagedFiles(root) {
+    const results = applyManagedFiles(root, 'check');
+    printResults(results);
+    if (results.some((result) => result.action === 'drifted')) {
+        throw new Error('Managed monorepo files are out of date. Run: smoo monorepo update');
+    }
+}
+export function diffManagedFiles(root) {
+    printResults(applyManagedFiles(root, 'diff'));
+}
+export function validateCommitMessageFile(path) {
+    if (!path) {
+        throw new Error('Usage: smoo monorepo validate-commit-msg <commit-msg-file>');
+    }
+    const message = readFileSync(path, 'utf8');
+    const error = validateCommitMessage(message);
+    if (error) {
+        throw new Error(error);
+    }
+}
+export function listPublicProjects(root) {
+    return listPublicPackages(root)
+        .map((pkg) => pkg.name)
+        .join(',');
+}
+export function validatePublicPackageTags(root) {
+    if (validatePublicTags(root) > 0) {
+        throw new Error('npm:public tag validation failed.');
+    }
+}
+export { applyWorkspaceGitConfig, syncBunLockfileVersions };

package/dist/monorepo/lockfile.d.ts

@@ -0,0 +1,2 @@
+export declare function syncBunLockfileVersions(root: string): void;
+//# sourceMappingURL=lockfile.d.ts.map

package/dist/monorepo/lockfile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lockfile.d.ts","sourceRoot":"","sources":["../../src/monorepo/lockfile.ts"],"names":[],"mappings":"AAIA,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAgC1D"}

package/dist/monorepo/lockfile.js

@@ -0,0 +1,34 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { escapeRegex, getWorkspacePackages } from '../lib/workspace.js';
+export function syncBunLockfileVersions(root) {
+    const lockfilePath = join(root, 'bun.lock');
+    if (!existsSync(lockfilePath)) {
+        throw new Error('bun.lock not found');
+    }
+    const packages = getWorkspacePackages(root);
+    let lockfile = readFileSync(lockfilePath, 'utf8');
+    let updated = 0;
+    for (const pkg of packages) {
+        const relativePath = pkg.path.replaceAll('\\', '/');
+        const escaped = escapeRegex(relativePath);
+        const pattern = new RegExp(`("${escaped}":\\s*\\{[^}]*"version":\\s*")([^"]+)(")`);
+        const match = lockfile.match(pattern);
+        if (!match) {
+            console.log(`skip: ${relativePath} (not found in lockfile)`);
+            continue;
+        }
+        const lockVersion = match[2];
+        if (lockVersion === pkg.version) {
+            console.log(`ok:   ${relativePath} = ${pkg.version}`);
+            continue;
+        }
+        lockfile = lockfile.replace(pattern, `$1${pkg.version}$3`);
+        console.log(`fix:  ${relativePath}: ${lockVersion} -> ${pkg.version}`);
+        updated++;
+    }
+    if (updated > 0) {
+        writeFileSync(lockfilePath, lockfile);
+    }
+    console.log(updated > 0 ? `Updated ${updated} workspace version(s) in bun.lock` : 'All workspace versions already in sync.');
+}

package/dist/monorepo/managed-files.d.ts

@@ -0,0 +1,8 @@
+export interface FileResult {
+    target: string;
+    action: 'created' | 'updated' | 'unchanged' | 'skipped-symlink' | 'drifted' | 'ok-symlink';
+}
+export declare function applyManagedFiles(root: string, mode: 'update' | 'check' | 'diff'): FileResult[];
+export declare function printResults(results: FileResult[]): void;
+export declare function validateManagedFiles(root: string): number;
+//# sourceMappingURL=managed-files.d.ts.map

package/dist/monorepo/managed-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-files.d.ts","sourceRoot":"","sources":["../../src/monorepo/managed-files.ts"],"names":[],"mappings":"AAcA,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,iBAAiB,GAAG,SAAS,GAAG,YAAY,CAAC;CAC5F;AAiED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,UAAU,EAAE,CAE/F;AAsDD,wBAAgB,YAAY,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,IAAI,CAIxD;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQzD"}

package/dist/monorepo/managed-files.js

@@ -0,0 +1,130 @@
+import { existsSync, lstatSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readPackageJson } from '../lib/workspace.js';
+const managedFiles = [
+    {
+        kind: 'raw',
+        source: 'tooling/direnv/github-actions-bootstrap.sh',
+        target: 'tooling/direnv/github-actions-bootstrap.sh',
+        executable: true,
+    },
+    {
+        kind: 'raw',
+        source: 'tooling/git-hooks/pre-commit.sh',
+        target: 'tooling/git-hooks/pre-commit.sh',
+        executable: true,
+    },
+    {
+        kind: 'raw',
+        source: 'tooling/git-hooks/commit-msg.sh',
+        target: 'tooling/git-hooks/commit-msg.sh',
+        executable: true,
+    },
+    {
+        kind: 'raw',
+        source: '.git-format-staged.yml',
+        target: '.git-format-staged.yml',
+    },
+    {
+        kind: 'template',
+        source: 'github/workflows/ci.yml',
+        target: '.github/workflows/ci.yml',
+    },
+    {
+        kind: 'template',
+        source: 'github/workflows/publish.yml',
+        target: '.github/workflows/publish.yml',
+    },
+    {
+        kind: 'template',
+        source: 'github/actions/cache-nix-devenv/action.yml',
+        target: '.github/actions/cache-nix-devenv/action.yml',
+    },
+    {
+        kind: 'template',
+        source: 'github/actions/setup-devenv/action.yml',
+        target: '.github/actions/setup-devenv/action.yml',
+    },
+    {
+        kind: 'template',
+        source: 'github/actions/save-nix-devenv/action.yml',
+        target: '.github/actions/save-nix-devenv/action.yml',
+    },
+    {
+        kind: 'template',
+        source: 'github/actions/cache-node-modules/action.yml',
+        target: '.github/actions/cache-node-modules/action.yml',
+    },
+    {
+        kind: 'template',
+        source: 'github/actions/cache-nx/action.yml',
+        target: '.github/actions/cache-nx/action.yml',
+    },
+];
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+export function applyManagedFiles(root, mode) {
+    return managedFiles.map((file) => applyManagedFile(root, file, mode));
+}
+function applyManagedFile(root, file, mode) {
+    const target = resolve(root, file.target);
+    const content = getManagedContent(root, file);
+    if (existsSync(target)) {
+        const info = lstatSync(target);
+        if (info.isSymbolicLink()) {
+            return { target: file.target, action: mode === 'check' ? 'ok-symlink' : 'skipped-symlink' };
+        }
+        if (!info.isFile()) {
+            throw new Error(`${file.target} exists but is not a regular file or symlink`);
+        }
+        const current = readFileSync(target, 'utf8');
+        if (current === content) {
+            return { target: file.target, action: 'unchanged' };
+        }
+        if (mode === 'check' || mode === 'diff') {
+            return { target: file.target, action: 'drifted' };
+        }
+        writeManagedFile(target, content, file.executable === true);
+        return { target: file.target, action: 'updated' };
+    }
+    if (mode === 'check' || mode === 'diff') {
+        return { target: file.target, action: 'drifted' };
+    }
+    writeManagedFile(target, content, file.executable === true);
+    return { target: file.target, action: 'created' };
+}
+function getManagedContent(root, file) {
+    const sourceRoot = file.kind === 'raw' ? 'managed/raw' : 'managed/templates';
+    const sourcePath = join(packageRoot, sourceRoot, file.source);
+    const content = readFileSync(sourcePath, 'utf8');
+    if (file.kind === 'raw') {
+        return content;
+    }
+    return renderTemplate(root, content);
+}
+function renderTemplate(root, template) {
+    const packageJson = readPackageJson(join(root, 'package.json'));
+    const repoName = packageJson?.name ?? 'monorepo';
+    const nodeModulesCacheKey = existsSync(join(root, 'bun.lock'))
+        ? `$${"{{ hashFiles('bun.lock', 'package.json', 'packages/*/package.json') }}"}`
+        : `$${"{{ hashFiles('bun.lockb', 'package.json', 'packages/*/package.json') }}"}`;
+    return template.replaceAll('{{REPO_NAME}}', repoName).replaceAll('{{NODE_MODULES_CACHE_KEY}}', nodeModulesCacheKey);
+}
+function writeManagedFile(path, content, executable) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, content, { mode: executable ? 0o755 : 0o644 });
+}
+export function printResults(results) {
+    for (const result of results) {
+        console.log(`${result.action.padEnd(15)} ${result.target}`);
+    }
+}
+export function validateManagedFiles(root) {
+    const results = applyManagedFiles(root, 'check');
+    printResults(results);
+    const failures = results.filter((result) => result.action === 'drifted').length;
+    if (failures > 0) {
+        console.error('Managed monorepo files are out of date. Run: smoo monorepo update');
+    }
+    return failures;
+}

package/dist/monorepo/nx-sync.d.ts

@@ -0,0 +1,2 @@
+export declare function validateNxSync(root: string): Promise<number>;
+//# sourceMappingURL=nx-sync.d.ts.map

package/dist/monorepo/nx-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nx-sync.d.ts","sourceRoot":"","sources":["../../src/monorepo/nx-sync.ts"],"names":[],"mappings":"AAEA,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAGlE"}

package/dist/monorepo/nx-sync.js

@@ -0,0 +1,5 @@
+import { runStatus } from '../lib/run.js';
+export async function validateNxSync(root) {
+    const status = await runStatus('nx', ['sync:check'], root);
+    return status === 0 ? 0 : 1;
+}

package/dist/monorepo/package-hygiene.d.ts

@@ -0,0 +1,3 @@
+export declare function fixPackageHygiene(root: string): Promise<void>;
+export declare function validatePackageHygiene(root: string): Promise<number>;
+//# sourceMappingURL=package-hygiene.d.ts.map

package/dist/monorepo/package-hygiene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-hygiene.d.ts","sourceRoot":"","sources":["../../src/monorepo/package-hygiene.ts"],"names":[],"mappings":"AAEA,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEnE;AAED,wBAAsB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAO1E"}

package/dist/monorepo/package-hygiene.js

@@ -0,0 +1,12 @@
+import { run, runStatus } from '../lib/run.js';
+export async function fixPackageHygiene(root) {
+    await run('sherif', ['--fix', '--select', 'highest'], root);
+}
+export async function validatePackageHygiene(root) {
+    const status = await runStatus('sherif', [], root);
+    if (status !== 0) {
+        console.error('sherif package hygiene validation failed');
+        return 1;
+    }
+    return 0;
+}