@fgv/repo-template 5.1.0-10

package/src/commands/init-library.ts

@@ -0,0 +1,313 @@
+/**
+ * init-library command — scaffolds a new library package within an existing Rush monorepo.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { patchFile, IPatchOperation } from '../packlets/jsonc';
+
+export type DepChannelType = 'alpha' | 'release' | 'auto';
+
+/**
+ * Check whether a given Rush repo root is the fgv source repo itself
+ * (as opposed to a consumer/sibling repo).
+ */
+function isFgvRepo(repoDir: string): boolean {
+  return fs.existsSync(path.join(repoDir, 'tools', 'repo-template', 'sync-manifest.json'));
+}
+
+/**
+ * Read the repo-template package's own version from its package.json.
+ */
+function getOwnPackageVersion(): string {
+  const pkgPath = path.resolve(__dirname, '..', '..', 'package.json');
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+  return pkg.version as string;
+}
+
+/**
+ * Resolve the @fgv/* dependency version spec for init-library.
+ *
+ * - In the fgv repo itself: returns "workspace:*"
+ * - In a sibling/consumer repo: derives a version range from the repo-template's own
+ *   package version, choosing alpha or release channel.
+ *
+ * @param repoDir - Rush monorepo root being targeted
+ * @param channel - "alpha" for prerelease, "release" for stable, "auto" to infer from
+ *   whether the repo-template is itself a prerelease build.
+ */
+export function resolveFgvDepVersion(repoDir: string, channel: DepChannelType): string {
+  if (isFgvRepo(repoDir)) {
+    return 'workspace:*';
+  }
+
+  const version = getOwnPackageVersion(); // e.g. "5.1.0-6" or "5.1.0"
+  const dashIdx = version.indexOf('-');
+  const baseVersion = dashIdx >= 0 ? version.substring(0, dashIdx) : version;
+  const isPrerelease = dashIdx >= 0;
+
+  const useAlpha = channel === 'alpha' || (channel === 'auto' && isPrerelease);
+  return useAlpha ? `~${baseVersion}-0` : `~${baseVersion}`;
+}
+
+export type RigType = 'dual' | 'node' | 'browser';
+export type CategoryType = 'libraries' | 'tools' | 'apps' | 'services';
+
+export interface IInitLibraryOptions {
+  /** Package name (e.g. "ts-my-lib" — will be prefixed with @fgv/) */
+  name: string;
+  /** Short description */
+  description: string;
+  /** Heft rig to use */
+  rig: RigType;
+  /** Category folder */
+  category: CategoryType;
+  /** Rush monorepo root */
+  repoDir: string;
+  /** Version policy name (from version-policies.json) */
+  versionPolicy: string;
+  /** Initial version */
+  version: string;
+  /** Dependency version for @fgv/* packages ("workspace:*" for fgv, "^5.1.0-0" for consumers) */
+  fgvDepVersion: string;
+}
+
+interface IRigConfig {
+  rigPackageName: string;
+  rigProfile?: string;
+  rigDevDeps: Record<string, string>;
+  tsconfigExtends: string;
+  tsconfigTypes: string[];
+  tsconfigLib?: string[];
+}
+
+const RIG_CONFIGS: Record<RigType, IRigConfig> = {
+  dual: {
+    rigPackageName: '@fgv/heft-dual-rig',
+    rigDevDeps: {
+      '@fgv/heft-dual-rig': 'FGV_DEP',
+      '@rushstack/heft': '1.2.7',
+      '@rushstack/heft-node-rig': '2.11.27'
+    },
+    tsconfigExtends: './node_modules/@rushstack/heft-node-rig/profiles/default/tsconfig-base.json',
+    tsconfigTypes: ['heft-jest', 'node'],
+    tsconfigLib: ['es2018']
+  },
+  node: {
+    rigPackageName: '@rushstack/heft-node-rig',
+    rigDevDeps: {
+      '@rushstack/heft': '1.2.7',
+      '@rushstack/heft-node-rig': '2.11.27'
+    },
+    tsconfigExtends: './node_modules/@rushstack/heft-node-rig/profiles/default/tsconfig-base.json',
+    tsconfigTypes: ['heft-jest', 'node']
+  },
+  browser: {
+    rigPackageName: '@rushstack/heft-web-rig',
+    rigProfile: 'library',
+    rigDevDeps: {
+      '@rushstack/heft': '1.2.7',
+      '@rushstack/heft-web-rig': '1.4.3'
+    },
+    tsconfigExtends: './node_modules/@rushstack/heft-web-rig/profiles/library/tsconfig-base.json',
+    tsconfigTypes: ['heft-jest', 'node'],
+    tsconfigLib: ['es2018', 'DOM']
+  }
+};
+
+export async function runInitLibrary(options: IInitLibraryOptions): Promise<void> {
+  const { name, description, rig, category, repoDir, versionPolicy, version, fgvDepVersion } = options;
+
+  const packageName = name.startsWith('@fgv/') ? name : `@fgv/${name}`;
+  const shortName = packageName.replace('@fgv/', '');
+  const projectFolder = `${category}/${shortName}`;
+  const projectDir = path.join(repoDir, projectFolder);
+
+  if (fs.existsSync(projectDir)) {
+    throw new Error(`Project directory already exists: ${projectDir}`);
+  }
+
+  const rushJsonPath = path.join(repoDir, 'rush.json');
+  if (!fs.existsSync(rushJsonPath)) {
+    throw new Error(`Not a Rush repo (no rush.json): ${repoDir}`);
+  }
+
+  const rigConfig = RIG_CONFIGS[rig];
+
+  console.log(`Initializing library: ${packageName}`);
+  console.log(`  Directory: ${projectFolder}`);
+  console.log(`  Rig:       ${rig} (${rigConfig.rigPackageName})`);
+  console.log(`  Version:   ${versionPolicy}@${version}`);
+  console.log('');
+
+  // ── Create directory structure ──
+  fs.mkdirSync(path.join(projectDir, 'src', 'test', 'unit'), { recursive: true });
+  fs.mkdirSync(path.join(projectDir, 'config'), { recursive: true });
+
+  // ── package.json ──
+  console.log('==> Creating package.json...');
+
+  const devDependencies: Record<string, string> = {};
+  // Add rig dependencies — @fgv/* packages use fgvDepVersion, others use their pinned version
+  for (const [dep, ver] of Object.entries(rigConfig.rigDevDeps)) {
+    devDependencies[dep] = dep.startsWith('@fgv/') ? fgvDepVersion : ver;
+  }
+  // Standard dev dependencies
+  devDependencies['@fgv/ts-utils-jest'] = fgvDepVersion;
+  devDependencies['@types/heft-jest'] = '1.0.6';
+  devDependencies['@types/jest'] = '^29.5.14';
+  devDependencies['@types/node'] = '^20.14.9';
+  devDependencies['typescript'] = '5.9.3';
+  devDependencies['@rushstack/eslint-config'] = '4.6.4';
+  devDependencies['eslint'] = '^9.39.2';
+  // Typedoc dependencies
+  devDependencies['typedoc'] = '~0.28.16';
+  devDependencies['@fgv/typedoc-compact-theme'] = fgvDepVersion;
+
+  const packageJson: Record<string, unknown> = {
+    name: packageName,
+    version,
+    description,
+    main: 'lib/index.js',
+    types: 'lib/index.d.ts',
+    scripts: {
+      build: 'heft build --clean',
+      clean: 'heft clean',
+      test: 'heft test --clean',
+      coverage: 'jest --coverage',
+      'build-docs': 'typedoc --options ./config/typedoc.json',
+      lint: 'eslint src --ext .ts',
+      fixlint: 'eslint src --ext .ts --fix'
+    },
+    author: '',
+    license: 'MIT',
+    dependencies: {
+      '@fgv/ts-utils': fgvDepVersion,
+      '@fgv/ts-json-base': fgvDepVersion
+    },
+    devDependencies,
+    repository: {
+      type: 'git',
+      url: ''
+    }
+  };
+
+  // Add dual-emit exports for dual rig
+  if (rig === 'dual') {
+    packageJson['module'] = 'dist/index.js';
+    packageJson['exports'] = {
+      '.': {
+        types: './lib/index.d.ts',
+        import: './dist/index.js',
+        require: './lib/index.js',
+        default: './lib/index.js'
+      }
+    };
+  }
+
+  fs.writeFileSync(path.join(projectDir, 'package.json'), JSON.stringify(packageJson, null, 2) + '\n');
+
+  // ── tsconfig.json ──
+  console.log('  Creating tsconfig.json...');
+
+  const tsconfig: Record<string, unknown> = {
+    extends: rigConfig.tsconfigExtends,
+    compilerOptions: {
+      types: rigConfig.tsconfigTypes,
+      ...(rigConfig.tsconfigLib ? { lib: rigConfig.tsconfigLib } : {})
+    }
+  };
+
+  fs.writeFileSync(path.join(projectDir, 'tsconfig.json'), JSON.stringify(tsconfig, null, 2) + '\n');
+
+  // ── config/rig.json ──
+  console.log('  Creating config/rig.json...');
+
+  const rigJson: Record<string, unknown> = {
+    $schema: 'https://developer.microsoft.com/json-schemas/rig-package/rig.schema.json',
+    rigPackageName: rigConfig.rigPackageName
+  };
+  if (rigConfig.rigProfile) {
+    rigJson['rigProfile'] = rigConfig.rigProfile;
+  }
+
+  fs.writeFileSync(path.join(projectDir, 'config', 'rig.json'), JSON.stringify(rigJson, null, 2) + '\n');
+
+  // ── config/jest.config.json ──
+  console.log('  Creating config/jest.config.json...');
+
+  const jestConfig = {
+    extends: '@rushstack/heft-node-rig/profiles/default/config/jest.config.json',
+    coverageThreshold: {
+      global: {
+        branches: 100,
+        functions: 100,
+        lines: 100,
+        statements: 100
+      }
+    },
+    collectCoverage: true,
+    coverageReporters: ['text', 'lcov', 'html']
+  };
+
+  fs.writeFileSync(
+    path.join(projectDir, 'config', 'jest.config.json'),
+    JSON.stringify(jestConfig, null, 2) + '\n'
+  );
+
+  // ── config/typedoc.json ──
+  console.log('  Creating config/typedoc.json...');
+
+  const typedocConfig = {
+    $schema: 'https://typedoc.org/schema.json',
+    extends: ['@fgv/heft-dual-rig/profiles/default/config/typedoc.compact-base.json'],
+    plugin: ['../../../plugins/typedoc-compact-theme/lib/index.js'],
+    entryPoints: ['../src/index.ts'],
+    out: '../docs'
+  };
+
+  fs.writeFileSync(
+    path.join(projectDir, 'config', 'typedoc.json'),
+    JSON.stringify(typedocConfig, null, 2) + '\n'
+  );
+
+  // ── src/index.ts ──
+  console.log('  Creating src/index.ts...');
+
+  fs.writeFileSync(
+    path.join(projectDir, 'src', 'index.ts'),
+    `/**\n * @packageDocumentation\n * ${description}\n */\n`
+  );
+
+  // ── Register in rush.json ──
+  console.log('');
+  console.log('==> Registering in rush.json...');
+
+  const rushJsonOps: IPatchOperation[] = [
+    {
+      type: 'add-to-array',
+      path: 'projects',
+      value: JSON.stringify({
+        packageName,
+        projectFolder,
+        shouldPublish: true,
+        versionPolicyName: versionPolicy,
+        tags: [category]
+      })
+    }
+  ];
+
+  patchFile(rushJsonPath, rushJsonOps);
+  console.log(`  Added ${packageName} at ${projectFolder}`);
+
+  // ── Done ──
+  console.log('');
+  console.log(`=== Library ${packageName} initialized at ${projectFolder} ===`);
+  console.log('');
+  console.log('Next steps:');
+  console.log(`  1. cd ${projectDir}`);
+  console.log('  2. rush update');
+  console.log('  3. rushx build');
+  console.log('  4. Start adding code to src/');
+  console.log('');
+}

package/src/commands/link.ts

@@ -0,0 +1,299 @@
+/**
+ * Link/unlink/update-fgv-versions commands — automate cross-repo development
+ * between fgv and consumer Rush monorepos.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import { parse as parseJsonc } from 'jsonc-parser';
+import { IPatchOperation, patchFile } from '../packlets/jsonc';
+
+// ── Interfaces ──
+
+export interface ILinkOptions {
+  fgvDir: string;
+  repoDir: string;
+}
+
+export interface IUnlinkOptions {
+  repoDir: string;
+  version?: string;
+}
+
+export interface IUpdateFgvVersionsOptions {
+  repoDir: string;
+  version?: string;
+}
+
+interface IRushProject {
+  packageName: string;
+  projectFolder: string;
+}
+
+// ── Discovery helpers ──
+
+/**
+ * Read a rush.json and return its project entries.
+ */
+function readRushProjects(rushJsonPath: string): IRushProject[] {
+  const content = fs.readFileSync(rushJsonPath, 'utf-8');
+  const rush = parseJsonc(content) as { projects: IRushProject[] };
+  return rush.projects;
+}
+
+/**
+ * Scan a consumer Rush repo and collect all @fgv/* dependencies (excluding workspace:* entries).
+ * Returns a map of packageName -> list of project folders that depend on it.
+ */
+function discoverFgvDeps(repoDir: string): Map<string, string[]> {
+  const rushJsonPath = path.join(repoDir, 'rush.json');
+  if (!fs.existsSync(rushJsonPath)) {
+    throw new Error(`rush.json not found at ${rushJsonPath}`);
+  }
+
+  const projects = readRushProjects(rushJsonPath);
+  const deps = new Map<string, string[]>();
+
+  for (const project of projects) {
+    const pkgJsonPath = path.join(repoDir, project.projectFolder, 'package.json');
+    if (!fs.existsSync(pkgJsonPath)) {
+      continue;
+    }
+
+    const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+    const allDeps: Record<string, string> = {
+      ...pkgJson.dependencies,
+      ...pkgJson.devDependencies
+    };
+
+    for (const [name, spec] of Object.entries(allDeps)) {
+      if (name.startsWith('@fgv/') && spec !== 'workspace:*') {
+        const existing = deps.get(name) ?? [];
+        existing.push(project.projectFolder);
+        deps.set(name, existing);
+      }
+    }
+  }
+
+  return deps;
+}
+
+/**
+ * Read the fgv worktree's rush.json and build a map of packageName -> projectFolder.
+ */
+function buildFgvPackageMap(fgvDir: string): Map<string, string> {
+  const rushJsonPath = path.join(fgvDir, 'rush.json');
+  if (!fs.existsSync(rushJsonPath)) {
+    throw new Error(`fgv rush.json not found at ${rushJsonPath}`);
+  }
+
+  const projects = readRushProjects(rushJsonPath);
+  const map = new Map<string, string>();
+  for (const project of projects) {
+    map.set(project.packageName, project.projectFolder);
+  }
+  return map;
+}
+
+// ── Version helpers ──
+
+/**
+ * Query npm for the latest prerelease version of @fgv/ts-utils and construct a ~X.Y.Z spec.
+ */
+function resolveLatestFgvVersion(): string {
+  const output = execSync('npm view @fgv/ts-utils dist-tags --json', { encoding: 'utf-8' });
+  const tags = JSON.parse(output) as Record<string, string>;
+  const version = tags.alpha ?? tags.latest;
+  if (!version) {
+    throw new Error('Could not determine latest @fgv version from npm dist-tags');
+  }
+  return `~${version}`;
+}
+
+/**
+ * Update all @fgv/* dependency versions (excluding workspace:*) in a consumer repo's package.json files.
+ * Uses jsonc-parser modify() to preserve formatting.
+ */
+function updateVersionsInPackageJsons(repoDir: string, versionSpec: string): string[] {
+  const rushJsonPath = path.join(repoDir, 'rush.json');
+  const projects = readRushProjects(rushJsonPath);
+  const changed: string[] = [];
+
+  for (const project of projects) {
+    const pkgJsonPath = path.join(repoDir, project.projectFolder, 'package.json');
+    if (!fs.existsSync(pkgJsonPath)) {
+      continue;
+    }
+
+    const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+    const operations: IPatchOperation[] = [];
+
+    for (const depField of ['dependencies', 'devDependencies'] as const) {
+      const deps: Record<string, string> | undefined = pkgJson[depField];
+      if (!deps) continue;
+
+      for (const [name, spec] of Object.entries(deps)) {
+        if (name.startsWith('@fgv/') && spec !== 'workspace:*') {
+          operations.push({
+            type: 'set-json',
+            path: `${depField}.${name}`,
+            value: JSON.stringify(versionSpec)
+          });
+        }
+      }
+    }
+
+    if (operations.length > 0) {
+      patchFile(pkgJsonPath, operations);
+      changed.push(pkgJsonPath);
+    }
+  }
+
+  return changed;
+}
+
+// ── Command runners ──
+
+export async function runLink(options: ILinkOptions): Promise<void> {
+  const { fgvDir, repoDir } = options;
+
+  console.log(`==> Linking to local fgv worktree`);
+  console.log(`  fgv dir:  ${fgvDir}`);
+  console.log(`  repo dir: ${repoDir}`);
+
+  const fgvDeps = discoverFgvDeps(repoDir);
+  if (fgvDeps.size === 0) {
+    console.log('  No @fgv/* dependencies found in consumer repo.');
+    return;
+  }
+
+  const fgvPackageMap = buildFgvPackageMap(fgvDir);
+
+  // Compute file: overrides relative to common/temp/
+  const commonTempDir = path.join(repoDir, 'common', 'temp');
+  const overrides: Record<string, string> = {};
+  const warnings: string[] = [];
+
+  for (const packageName of fgvDeps.keys()) {
+    const projectFolder = fgvPackageMap.get(packageName);
+    if (!projectFolder) {
+      warnings.push(`  Warning: ${packageName} not found in fgv worktree — skipping`);
+      continue;
+    }
+    const absoluteProjectPath = path.join(fgvDir, projectFolder);
+    const relativePath = path.relative(commonTempDir, absoluteProjectPath);
+    overrides[packageName] = `file:${relativePath}`;
+  }
+
+  for (const w of warnings) {
+    console.warn(w);
+  }
+
+  // Patch pnpm-config.json
+  const pnpmConfigPath = path.join(repoDir, 'common', 'config', 'rush', 'pnpm-config.json');
+  if (!fs.existsSync(pnpmConfigPath)) {
+    throw new Error(`pnpm-config.json not found at ${pnpmConfigPath}`);
+  }
+
+  const patchOps: IPatchOperation[] = [
+    {
+      type: 'set-json',
+      path: 'globalOverrides',
+      value: JSON.stringify(overrides)
+    },
+    {
+      type: 'set',
+      path: 'strictPeerDependencies',
+      value: false
+    },
+    {
+      type: 'set-json',
+      path: 'globalPeerDependencyRules',
+      value: JSON.stringify({ ignoreMissing: ['mustache'], allowAny: ['@fgv/*'] })
+    }
+  ];
+
+  patchFile(pnpmConfigPath, patchOps);
+
+  console.log(`\n  Patched: ${pnpmConfigPath}`);
+  console.log(`  Overrides (${Object.keys(overrides).length} packages):`);
+  for (const [name, filePath] of Object.entries(overrides)) {
+    console.log(`    ${name} -> ${filePath}`);
+  }
+  console.log(`\n  Next: run "rush update --purge" in the consumer repo.`);
+}
+
+export async function runUnlink(options: IUnlinkOptions): Promise<void> {
+  const { repoDir, version } = options;
+
+  console.log(`==> Unlinking from local fgv worktree`);
+  console.log(`  repo dir: ${repoDir}`);
+
+  // Restore pnpm-config.json to defaults
+  const pnpmConfigPath = path.join(repoDir, 'common', 'config', 'rush', 'pnpm-config.json');
+  if (!fs.existsSync(pnpmConfigPath)) {
+    throw new Error(`pnpm-config.json not found at ${pnpmConfigPath}`);
+  }
+
+  const patchOps: IPatchOperation[] = [
+    {
+      type: 'set-json',
+      path: 'globalOverrides',
+      value: JSON.stringify({})
+    },
+    {
+      type: 'set',
+      path: 'strictPeerDependencies',
+      value: true
+    },
+    {
+      type: 'set-json',
+      path: 'globalPeerDependencyRules',
+      value: JSON.stringify({})
+    }
+  ];
+
+  patchFile(pnpmConfigPath, patchOps);
+  console.log(`  Patched: ${pnpmConfigPath} (restored defaults)`);
+
+  // Optionally bump versions
+  if (version) {
+    console.log(`\n  Bumping @fgv/* deps to ${version}...`);
+    const changed = updateVersionsInPackageJsons(repoDir, version);
+    console.log(`  Updated ${changed.length} package.json file(s):`);
+    for (const f of changed) {
+      console.log(`    ${f}`);
+    }
+  }
+
+  console.log(`\n  Next: run "rush update --purge" in the consumer repo.`);
+}
+
+export async function runUpdateFgvVersions(options: IUpdateFgvVersionsOptions): Promise<void> {
+  const { repoDir } = options;
+
+  console.log(`==> Updating @fgv/* version specs`);
+  console.log(`  repo dir: ${repoDir}`);
+
+  // Resolve version
+  let versionSpec: string;
+  if (options.version) {
+    versionSpec = options.version;
+    console.log(`  Using explicit version: ${versionSpec}`);
+  } else {
+    console.log('  Querying npm for latest version...');
+    versionSpec = resolveLatestFgvVersion();
+    console.log(`  Resolved version: ${versionSpec}`);
+  }
+
+  const changed = updateVersionsInPackageJsons(repoDir, versionSpec);
+  console.log(`\n  Updated ${changed.length} package.json file(s):`);
+  for (const f of changed) {
+    console.log(`    ${f}`);
+  }
+
+  if (changed.length > 0) {
+    console.log(`\n  Next: run "rush update --purge" in the consumer repo.`);
+  }
+}

package/src/commands/patch.ts

@@ -0,0 +1,84 @@
+/**
+ * Patch command — apply targeted edits to JSONC config files.
+ */
+
+import * as fs from 'fs';
+import { IPatchOperation, PatchOperationType, applyOperations, parseValue } from '../packlets/jsonc';
+
+export interface IPatchOptions {
+  file: string;
+  operations: IPatchOperation[];
+}
+
+/**
+ * Parse CLI arguments for the patch command into operations.
+ * Expects pairs like: --set 'path=value', --uncomment 'path', etc.
+ */
+export function parsePatchArgs(args: string[]): IPatchOperation[] {
+  const operations: IPatchOperation[] = [];
+  const validOps: PatchOperationType[] = ['set', 'set-json', 'uncomment', 'add-to-array', 'remove'];
+
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (!arg.startsWith('--')) {
+      throw new Error(`Unexpected argument: ${arg}`);
+    }
+
+    const opType = arg.slice(2) as PatchOperationType;
+    if (!validOps.includes(opType)) {
+      throw new Error(`Unknown operation: ${arg}`);
+    }
+
+    i++;
+    if (i >= args.length) {
+      throw new Error(`Missing value for ${arg}`);
+    }
+
+    const operand = args[i];
+    i++;
+
+    if (opType === 'uncomment' || opType === 'remove') {
+      operations.push({ type: opType, path: operand });
+    } else {
+      const eqIndex = operand.indexOf('=');
+      if (eqIndex === -1) {
+        throw new Error(`Expected path=value for ${arg}, got: ${operand}`);
+      }
+      const opPath = operand.slice(0, eqIndex);
+      const rawValue = operand.slice(eqIndex + 1);
+
+      if (opType === 'set') {
+        operations.push({ type: opType, path: opPath, value: parseValue(rawValue) });
+      } else {
+        // set-json and add-to-array pass raw JSON string
+        operations.push({ type: opType, path: opPath, value: rawValue });
+      }
+    }
+  }
+
+  return operations;
+}
+
+export async function runPatch(options: IPatchOptions): Promise<void> {
+  const { file, operations } = options;
+
+  if (!fs.existsSync(file)) {
+    throw new Error(`File not found: ${file}`);
+  }
+
+  console.log(`Patching: ${file}`);
+  let source = fs.readFileSync(file, 'utf-8');
+
+  for (const op of operations) {
+    const desc =
+      op.type === 'uncomment' || op.type === 'remove'
+        ? `  ${op.type}: ${op.path}`
+        : `  ${op.type}: ${op.path} = ${op.value}`;
+    console.log(desc);
+  }
+
+  source = applyOperations(source, operations);
+  fs.writeFileSync(file, source);
+  console.log(`  Done: ${operations.length} operation(s) applied`);
+}