@rtorcato/repo-tooling 2.59.0

package/dist/cli/utils/detect-language.js

@@ -0,0 +1,22 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+/**
+ * Marker files that identify a repo's language, checked in order — first match
+ * wins. One language per repo root; multi-language monorepos are out of scope
+ * for v1 (see #139). A dir with no marker → 'unknown' (base checks only).
+ */
+const MARKERS = [
+    ['js', ['package.json']],
+    ['swift', ['Package.swift']],
+    ['perl', ['cpanfile', 'Makefile.PL', 'dist.ini']],
+    ['python', ['pyproject.toml', 'setup.py']],
+];
+export async function detectLanguage(dir) {
+    for (const [language, candidates] of MARKERS) {
+        for (const candidate of candidates) {
+            if (await fs.pathExists(path.join(dir, candidate)))
+                return language;
+        }
+    }
+    return 'unknown';
+}

package/dist/cli/utils/format.js

@@ -0,0 +1,32 @@
+import chalk from 'chalk';
+import { spawn } from 'node:child_process';
+function run(cmd, args, cwd) {
+    return new Promise((resolve) => {
+        const child = spawn(cmd, args, { cwd, stdio: 'inherit', shell: true });
+        child.on('close', (code) => resolve(code ?? 1));
+        child.on('error', () => resolve(1));
+    });
+}
+/**
+ * Generated config files come from hand-built templates whose whitespace doesn't
+ * match the project's shipped formatter (biome collapses JSON arrays and uses
+ * tabs + trailing commas). Run the formatter once, post-install, so a fresh
+ * scaffold passes its own `pnpm check` / lint out of the box instead of failing
+ * on the consumer's first verify. Best-effort: never fails setup.
+ */
+export async function formatGeneratedFiles(config, targetDir) {
+    const usesBiome = config.linting.tool === 'biome' || config.linting.tool === 'both';
+    const usesEslint = config.linting.tool === 'eslint' || config.linting.tool === 'both';
+    if (usesBiome) {
+        await run('pnpm', ['exec', 'biome', 'check', '--write', '.'], targetDir);
+    }
+    if (config.formatting.tool === 'prettier') {
+        await run('pnpm', ['exec', 'prettier', '--write', '.'], targetDir);
+    }
+    if (usesEslint) {
+        await run('pnpm', ['exec', 'eslint', '.', '--fix'], targetDir);
+    }
+    if (usesBiome || usesEslint || config.formatting.tool === 'prettier') {
+        console.log(chalk.green('✨ Formatted generated files'));
+    }
+}

package/dist/cli/utils/install.js

@@ -0,0 +1,28 @@
+import chalk from 'chalk';
+import { spawn } from 'node:child_process';
+export async function installDependencies(_config, targetDir) {
+    return new Promise((resolve) => {
+        console.log(chalk.blue('📦 Installing dependencies with pnpm...'));
+        const child = spawn('pnpm', ['install'], {
+            cwd: targetDir,
+            stdio: 'inherit',
+            shell: true,
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                console.log(chalk.green('✅ Dependencies installed successfully!'));
+                resolve();
+            }
+            else {
+                console.error(chalk.red(`❌ pnpm install failed with code ${code}`));
+                console.log(chalk.yellow('💡 You can install dependencies manually with: pnpm install'));
+                resolve(); // Don't reject, just warn
+            }
+        });
+        child.on('error', (error) => {
+            console.error(chalk.red('❌ Error running pnpm install:'), error.message);
+            console.log(chalk.yellow('💡 You can install dependencies manually with: pnpm install'));
+            resolve(); // Don't reject, just warn
+        });
+    });
+}

package/dist/cli/utils/lockfile.js

@@ -0,0 +1,84 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import packageJson from '../../../package.json' with { type: 'json' };
+import { validateProjectConfig } from '../commands/setup-presets.js';
+export const LOCKFILE_NAME = '.repo-tooling.json';
+// Name used before the js-tooling→repo-tooling rename (#272). Repos set up on an
+// older version still have it: readLockfile falls back to it, and writeLockfile
+// migrates to the new name (removing the old file) on the next write.
+export const LEGACY_LOCKFILE_NAME = '.js-tooling.json';
+// v2 added ProjectConfig.language (multi-language seam, #140). v1 files are
+// migrated to v2 on read, defaulting language to 'js'.
+export const LOCKFILE_VERSION = 2;
+const LOCKFILE_SCHEMA_URL = 'https://rtorcato.github.io/repo-tooling/schemas/lockfile.json';
+/**
+ * Upgrade an older lockfile in-memory. Only touches files older than the
+ * current version, so a newer-than-supported file is left as-is for
+ * checkLockfile to flag. The file is rewritten to v2 next time it's saved.
+ */
+function migrate(lock) {
+    if (lock.version >= LOCKFILE_VERSION)
+        return lock;
+    return {
+        ...lock,
+        version: LOCKFILE_VERSION,
+        config: { language: 'js', ...lock.config },
+    };
+}
+export async function readLockfile(dir) {
+    let filepath = path.join(dir, LOCKFILE_NAME);
+    if (!(await fs.pathExists(filepath))) {
+        // Fall back to the pre-rename name so existing repos keep working (#272).
+        const legacy = path.join(dir, LEGACY_LOCKFILE_NAME);
+        if (!(await fs.pathExists(legacy)))
+            return null;
+        filepath = legacy;
+    }
+    try {
+        const raw = (await fs.readJson(filepath));
+        if (typeof raw !== 'object' || raw === null)
+            return null;
+        const obj = raw;
+        if (typeof obj.version !== 'number')
+            return null;
+        if (typeof obj.config !== 'object' || obj.config === null)
+            return null;
+        return migrate(obj);
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeLockfile(dir, config) {
+    const { valid, errors } = validateProjectConfig(config);
+    if (!valid) {
+        throw new Error(`Refusing to write invalid lockfile:\n  - ${errors.join('\n  - ')}`);
+    }
+    const filepath = path.join(dir, LOCKFILE_NAME);
+    const lockfile = {
+        $schema: LOCKFILE_SCHEMA_URL,
+        version: LOCKFILE_VERSION,
+        config,
+        writtenBy: `@rtorcato/repo-tooling@${packageJson.version}`,
+        writtenAt: new Date().toISOString(),
+    };
+    await fs.writeJson(filepath, lockfile, { spaces: 2 });
+    // Migrate a pre-rename repo to the new name: now that the canonical file is
+    // written, drop the stale legacy lockfile so there's only one (#272).
+    const legacy = path.join(dir, LEGACY_LOCKFILE_NAME);
+    if (await fs.pathExists(legacy))
+        await fs.remove(legacy);
+    return filepath;
+}
+/**
+ * Patch a subset of a lockfile's config in place, preserving everything else.
+ * Returns true when the file was rewritten, false when no lockfile exists.
+ */
+export async function updateLockfileConfig(dir, patch) {
+    const existing = await readLockfile(dir);
+    if (!existing)
+        return false;
+    const merged = { ...existing.config, ...patch };
+    await writeLockfile(dir, merged);
+    return true;
+}