feat: update librarian.yaml for Node

This introduces a new Node strategy specifically for
https://github.com/googleapis/google-cloud-node, with an updater which
is aware of the expected Librarian format for Node.

Once Librarian has moved off release-please, the strategy and updater
can be removed.

Towards googleapis/librarian#5461

Author: jskeet

src/strategies/node-librarian.ts

@@ -0,0 +1,146 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import {BaseStrategy, BuildUpdatesOptions} from './base';
+import {Update} from '../update';
+import {ChangelogJson} from '../updaters/changelog-json';
+import {PackageLockJson} from '../updaters/node/package-lock-json';
+import {SamplesPackageJson} from '../updaters/node/samples-package-json';
+import {Changelog} from '../updaters/changelog';
+import {PackageJson} from '../updaters/node/package-json';
+import {LibrarianYamlUpdater} from '../updaters/node/librarian-yaml';
+import {GitHubFileContents} from '@google-automations/git-file-utils';
+import {FileNotFoundError, MissingRequiredFileError} from '../errors';
+import {filterCommits} from '../util/filter-commits';
+
+export class NodeLibrarian extends BaseStrategy {
+  private pkgJsonContents?: GitHubFileContents;
+
+  protected async buildUpdates(
+    options: BuildUpdatesOptions
+  ): Promise<Update[]> {
+    const updates: Update[] = [];
+    const version = options.newVersion;
+    const versionsMap = options.versionsMap;
+    const packageName = (await this.getPackageName()) ?? '';
+    const lockFiles = ['package-lock.json', 'npm-shrinkwrap.json'];
+    const librarianFilesSearch = this.github.findFilesByFilenameAndRef(
+      'librarian.yaml',
+      this.targetBranch,
+      this.path
+    );
+    lockFiles.forEach(lockFile => {
+      updates.push({
+        path: this.addPath(lockFile),
+        createIfMissing: false,
+        updater: new PackageLockJson({
+          version,
+          versionsMap,
+        }),
+      });
+    });
+
+    updates.push({
+      path: this.addPath('samples/package.json'),
+      createIfMissing: false,
+      updater: new SamplesPackageJson({
+        version,
+        packageName,
+      }),
+    });
+
+    !this.skipChangelog &&
+      updates.push({
+        path: this.addPath(this.changelogPath),
+        createIfMissing: true,
+        updater: new Changelog({
+          version,
+          changelogEntry: options.changelogEntry,
+        }),
+      });
+
+    updates.push({
+      path: this.addPath('package.json'),
+      createIfMissing: false,
+      cachedFileContents: this.pkgJsonContents,
+      updater: new PackageJson({
+        version,
+      }),
+    });
+
+    // If a machine readable changelog.json exists update it:
+    if (options.commits && packageName && !this.skipChangelog) {
+      const commits = filterCommits(options.commits, this.changelogSections);
+      updates.push({
+        path: 'changelog.json',
+        createIfMissing: false,
+        updater: new ChangelogJson({
+          artifactName: packageName,
+          version,
+          commits,
+          language: 'JAVASCRIPT',
+        }),
+      });
+    }
+
+    // Update librarian.yaml for every matching library.
+    const librarianFiles = await librarianFilesSearch;
+      librarianFiles.forEach(path => {
+        updates.push({
+          path: this.addPath(path),
+          createIfMissing: false,
+          updater: new LibrarianYamlUpdater({
+            version,
+            versionsMap,
+          }),
+        });
+      });
+
+    return updates;
+  }
+
+  async getDefaultPackageName(): Promise<string | undefined> {
+    const pkgJsonContents = await this.getPkgJsonContents();
+    const pkg = JSON.parse(pkgJsonContents.parsedContent);
+    return pkg.name;
+  }
+
+  protected normalizeComponent(component: string | undefined): string {
+    if (!component) {
+      return '';
+    }
+    return component.match(/^@[\w-]+\//) ? component.split('/')[1] : component;
+  }
+
+  protected async getPkgJsonContents(): Promise<GitHubFileContents> {
+    if (!this.pkgJsonContents) {
+      try {
+        this.pkgJsonContents = await this.github.getFileContentsOnBranch(
+          this.addPath('package.json'),
+          this.targetBranch
+        );
+      } catch (e) {
+        if (e instanceof FileNotFoundError) {
+          throw new MissingRequiredFileError(
+            this.addPath('package.json'),
+            'node',
+            `${this.repository.owner}/${this.repository.repo}`
+          );
+        }
+        throw e;
+      }
+    }
+    return this.pkgJsonContents;
+  }
+}

src/updaters/node/librarian-yaml.ts

@@ -0,0 +1,89 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import {DefaultUpdater} from '../default';
+import * as yaml from 'yaml';
+import {logger as defaultLogger, Logger} from '../../util/logger';
+
+export interface LibrarianLibrary {
+  name: string;
+  output: string;
+  version: string;
+  [key: string]: any;
+}
+
+export interface LibrarianYamlSchema {
+  libraries: LibrarianLibrary[];
+  [key: string]: any;
+}
+
+/**
+ * Updates a librarian.yaml file.
+ */
+export class LibrarianYamlUpdater extends DefaultUpdater {
+  /**
+   * Given initial file contents, return updated contents.
+   * @param {string} content The initial content
+   * @returns {string} The updated content
+   */
+  updateContent(content: string, logger: Logger = defaultLogger): string {
+    if (!this.versionsMap) {
+      logger.warn('missing versions map');
+      return content;
+    }
+
+    // Use yaml package to make sure librarian.yaml is not reformatted because
+    // we use different tool to format librarian.yaml.
+    const doc = yaml.parseDocument(content);
+    if (!doc || doc.errors.length > 0) {
+      logger.warn('Invalid yaml, cannot be parsed');
+      return content;
+    }
+
+    const libraries = doc.get('libraries');
+    if (!libraries || !yaml.isSeq(libraries)) {
+      return content;
+    }
+
+    let modified = false;
+    for (const library of libraries.items) {
+      if (!yaml.isMap(library)) continue;
+
+      // The release-please version map key is the output directory (explicit or
+      // derived) in librarian.yaml.
+      const outputDirectory = this.deriveOutputDirectory(
+        library.toJSON() as LibrarianLibrary
+      );
+      if (this.versionsMap.has(outputDirectory)) {
+        const newVersion = this.versionsMap.get(outputDirectory);
+        if (newVersion && library.get('version') !== newVersion.toString()) {
+          library.set('version', newVersion.toString());
+          modified = true;
+        }
+      }
+    }
+
+    if (modified) {
+      return doc.toString({lineWidth: 0});
+    }
+    return content;
+  }
+
+  deriveOutputDirectory(library: LibrarianLibrary): string {
+    if (library.output) {
+      return library.output;
+    }
+    return `packages/${library.name}`;
+  }
+}