@tallyrelease/plugins 0.0.0-stage → 0.0.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

package/README.md

@@ -1,3 +1,5 @@
-# Temporary Holding Version
+# @tallyrelease/plugins
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Built-in ecosystem plugins (`node`, `php`, `kustomize`, `dart`) of [tallyrelease](https://github.com/abinnovision/tallyrelease). They are pure: files are read only through the `Ctx` that `@tallyrelease/core` injects.
+
+Most users want [`@tallyrelease/cli`](https://www.npmjs.com/package/@tallyrelease/cli) instead, which bundles these plugins.

package/dist/_kit/edges.d.ts

@@ -0,0 +1,11 @@
+import type { EdgeDraft, Unit } from "@tallyrelease/core";
+/** Units of `plugin` keyed by package name; `onDuplicate` sees each shadowed unit. */
+export declare const unitsByPackage: (units: readonly Unit[], plugin: string, onDuplicate?: (name: string, prior: Unit, next: Unit) => void) => Map<string, Unit>;
+/** The edge `from` -> `to`; empty when `from` is unknown or the same unit. */
+export declare const edgeBetween: (from: Unit | undefined, to: Unit, link: Pick<EdgeDraft, "reason" | "pinned">) => EdgeDraft[];
+/** Edges for each entry of `deps` that names a unit in `byName`; `exact` marks pinned ranges. */
+export declare const dependencyEdges: (byName: ReadonlyMap<string, Unit>, to: Unit, { field, deps, exact, }: {
+    field: string;
+    deps: Record<string, string>;
+    exact: RegExp | undefined;
+}) => EdgeDraft[];

package/dist/_kit/edges.js

@@ -0,0 +1,22 @@
+/** Units of `plugin` keyed by package name; `onDuplicate` sees each shadowed unit. */
+export const unitsByPackage = (units, plugin, onDuplicate) => {
+    const byName = new Map();
+    for (const unit of units) {
+        const name = unit.meta[plugin]?.["packageName"];
+        if (unit.plugin === plugin && typeof name === "string") {
+            const prior = byName.get(name);
+            if (prior) {
+                onDuplicate?.(name, prior, unit);
+            }
+            byName.set(name, unit);
+        }
+    }
+    return byName;
+};
+/** The edge `from` -> `to`; empty when `from` is unknown or the same unit. */
+export const edgeBetween = (from, to, link) => from && from.id !== to.id ? [{ from: from.id, to: to.id, ...link }] : [];
+/** Edges for each entry of `deps` that names a unit in `byName`; `exact` marks pinned ranges. */
+export const dependencyEdges = (byName, to, { field, deps, exact, }) => Object.entries(deps).flatMap(([name, range]) => edgeBetween(byName.get(name), to, {
+    reason: `${field}: ${name}`,
+    pinned: exact?.test(range) ?? false,
+}));

package/dist/_kit/manifest.d.ts

@@ -0,0 +1,5 @@
+import type { Ctx } from "@tallyrelease/core";
+/** Parses a JSON manifest; a syntax error names the file. */
+export declare const parseJson: (path: string, raw: string) => unknown;
+/** Reads and parses `file` inside unit `root`; undefined when it is missing. */
+export declare const readManifest: (ctx: Pick<Ctx, "fs">, root: string, file: string) => Record<string, unknown> | undefined;

package/dist/_kit/manifest.js

@@ -0,0 +1,19 @@
+import { joinRoot } from "./paths.js";
+/** Parses a JSON manifest; a syntax error names the file. */
+export const parseJson = (path, raw) => {
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`invalid JSON in ${path}: ${reason}`, { cause: error });
+    }
+};
+/** Reads and parses `file` inside unit `root`; undefined when it is missing. */
+export const readManifest = (ctx, root, file) => {
+    const path = joinRoot(root, file);
+    const raw = ctx.fs.read(path);
+    return raw === undefined
+        ? undefined
+        : parseJson(path, raw);
+};

package/dist/_kit/paths.d.ts

@@ -0,0 +1,6 @@
+/** Repo-relative path of `file` inside unit `root` (`.` is the repo root). */
+export declare const joinRoot: (root: string, file: string) => string;
+/** Glob for `file` inside `dir`, ignoring trailing slashes on `dir`. */
+export declare const globIn: (dir: string, file: string) => string;
+/** Unit root of a matched `<root>/<file>` path. */
+export declare const rootOf: (path: string, file: string) => string;

package/dist/_kit/paths.js

@@ -0,0 +1,6 @@
+/** Repo-relative path of `file` inside unit `root` (`.` is the repo root). */
+export const joinRoot = (root, file) => root === "." ? file : `${root}/${file}`;
+/** Glob for `file` inside `dir`, ignoring trailing slashes on `dir`. */
+export const globIn = (dir, file) => `${dir.replace(/\/+$/, "")}/${file}`;
+/** Unit root of a matched `<root>/<file>` path. */
+export const rootOf = (path, file) => path.slice(0, -`/${file}`.length);

package/dist/_kit/semver.d.ts

@@ -0,0 +1,6 @@
+/** Regex source for `major.minor.patch`. */
+export declare const NUMBERS: string;
+/** Regex source for an optional `-prerelease` suffix. */
+export declare const PRERELEASE: string;
+/** Regex source for an optional `+build` suffix. */
+export declare const BUILD: string;

package/dist/_kit/semver.js

@@ -0,0 +1,6 @@
+/** Regex source for `major.minor.patch`. */
+export const NUMBERS = String.raw `\d+\.\d+\.\d+`;
+/** Regex source for an optional `-prerelease` suffix. */
+export const PRERELEASE = String.raw `(?:-[0-9A-Za-z.-]+)?`;
+/** Regex source for an optional `+build` suffix. */
+export const BUILD = String.raw `(?:\+[0-9A-Za-z.-]+)?`;

package/dist/builtin.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "@tallyrelease/core";
+export declare const builtinPlugins: Record<string, Plugin<any>>;

package/dist/builtin.js

@@ -0,0 +1,14 @@
+import { changesetsPlugin } from "./changesets/plugin.js";
+import { dartPlugin } from "./dart/plugin.js";
+import { goPlugin } from "./go/plugin.js";
+import { kustomizePlugin } from "./kustomize/plugin.js";
+import { nodePlugin } from "./node/plugin.js";
+import { phpPlugin } from "./php/plugin.js";
+export const builtinPlugins = {
+    node: nodePlugin,
+    php: phpPlugin,
+    go: goPlugin,
+    kustomize: kustomizePlugin,
+    dart: dartPlugin,
+    changesets: changesetsPlugin,
+};

package/dist/changesets/plugin.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Changes from `.changeset/*.md` files touched in the range; each names its
+ * units explicitly and consumes its file.
+ */
+export declare const changesetsPlugin: import("@tallyrelease/core").Plugin<Record<string, never>>;

package/dist/changesets/plugin.js

@@ -0,0 +1,95 @@
+import { definePlugin } from "@tallyrelease/core";
+import { parse as parseYaml } from "yaml";
+import { z } from "zod";
+const FRONTMATTER = /^\uFEFF?\s*---[ \t]*\r?\n(?:([\s\S]*?)\r?\n)?---[ \t]*(?:\r?\n|$)([\s\S]*)$/;
+const KINDS = new Map([
+    ["major", { type: "feat", breaking: true }],
+    ["minor", { type: "feat", breaking: false }],
+    ["patch", { type: "fix", breaking: false }],
+]);
+/** Unit id by unit id, then by any `meta.*.packageName`. */
+const unitKeys = (units) => {
+    const keys = new Map(units.map((u) => [u.id, u.id]));
+    for (const unit of units) {
+        for (const meta of Object.values(unit.meta)) {
+            const name = meta["packageName"];
+            if (typeof name === "string" && !keys.has(name)) {
+                keys.set(name, unit.id);
+            }
+        }
+    }
+    return keys;
+};
+/**
+ * Changes of one changeset, one per bump level; none without frontmatter,
+ * which warns except for `README.md`.
+ */
+const changesOf = (ctx, path, keys) => {
+    const content = ctx.fs.read(path);
+    if (content === undefined) {
+        return [];
+    }
+    const match = FRONTMATTER.exec(content);
+    if (!match) {
+        if (path !== ".changeset/README.md") {
+            ctx.log.warn(`${path} has no frontmatter`);
+        }
+        return [];
+    }
+    let bumps;
+    try {
+        bumps = parseYaml(match[1] ?? "") ?? {};
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`invalid frontmatter in ${path}: ${reason}`, {
+            cause: error,
+        });
+    }
+    if (typeof bumps !== "object" || bumps === null || Array.isArray(bumps)) {
+        throw new Error(`frontmatter of ${path} must map packages to bumps`);
+    }
+    const byKind = new Map();
+    for (const [key, level] of Object.entries(bumps)) {
+        const kind = KINDS.get(level);
+        const id = keys.get(key) ?? key;
+        if (kind) {
+            const units = byKind.get(kind) ?? [];
+            byKind.set(kind, units.includes(id) ? units : [...units, id]);
+        }
+        else if (level !== "none") {
+            ctx.log.warn(`${path}: "${key}" has unknown bump "${String(level)}"`);
+        }
+    }
+    const [subject = "", ...rest] = match[2]?.trim().split("\n") ?? [];
+    const body = rest.join("\n").trim();
+    return [...byKind].map(([kind, units]) => ({
+        ...kind,
+        units,
+        subject: subject.trim(),
+        ...(body === "" ? {} : { body }),
+        files: [path],
+    }));
+};
+/**
+ * Changes from `.changeset/*.md` files touched in the range; each names its
+ * units explicitly and consumes its file.
+ */
+export const changesetsPlugin = definePlugin({
+    apiVersion: 1,
+    name: "changesets",
+    options: z.strictObject({}),
+    intent: [
+        {
+            name: "changesets",
+            collect: (ctx, { commits, units }) => {
+                const touched = new Set(commits.flatMap((c) => c.files));
+                const keys = unitKeys(units);
+                return ctx.fs
+                    .glob([".changeset/*.md"])
+                    .filter((path) => touched.has(path))
+                    .flatMap((path) => changesOf(ctx, path, keys));
+            },
+        },
+    ],
+});

package/dist/dart/plugin.d.ts

@@ -0,0 +1,3 @@
+export declare const dartPlugin: import("@tallyrelease/core").Plugin<{
+    buildOffset?: number | undefined;
+}>;

package/dist/dart/plugin.js

@@ -0,0 +1,98 @@
+import { defaultUnitId, definePlugin, flutter } from "@tallyrelease/core";
+import { parse as parseYaml } from "yaml";
+import { z } from "zod";
+import { edgeBetween, unitsByPackage } from "../_kit/edges.js";
+import { joinRoot, rootOf } from "../_kit/paths.js";
+const optionsSchema = z.strictObject({
+    /** Added to the first-parent commit count for flutter build numbers. */
+    buildOffset: z.number().int().nonnegative().optional(),
+});
+const PUBSPEC = "pubspec.yaml";
+const DEP_FIELDS = [
+    "dependencies",
+    "dev_dependencies",
+    "dependency_overrides",
+];
+/** The top-level `version:` line; group 3 is the value without quotes. */
+const VERSION_LINE = /^(version:[ \t]*)(["']?)([^\s"'#]+)\2/m;
+const record = (value) => typeof value === "object" && value !== null
+    ? value
+    : {};
+const readPubspec = (ctx, root) => {
+    const path = joinRoot(root, PUBSPEC);
+    const raw = ctx.fs.read(path);
+    if (raw === undefined) {
+        return undefined;
+    }
+    try {
+        return record(parseYaml(raw));
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`invalid YAML in ${path}: ${reason}`, { cause: error });
+    }
+};
+/** Directories whose pubspecs are never units. */
+const SKIPPED = new Set(["build", "example"]);
+/** Roots of every `pubspec.yaml`, skipping dot, `build` and `example` directories. */
+const pubspecRoots = (ctx) => ctx.fs
+    .glob([PUBSPEC, `**/${PUBSPEC}`])
+    .filter((p) => p
+    .split("/")
+    .slice(0, -1)
+    .every((s) => !s.startsWith(".") && !SKIPPED.has(s)))
+    .map((p) => (p === PUBSPEC ? "." : rootOf(p, PUBSPEC)));
+/** A private app that depends on the Flutter SDK. */
+const isFlutterApp = (pubspec) => pubspec["publish_to"] === "none" &&
+    (record(record(pubspec["dependencies"])["flutter"])["sdk"] === "flutter" ||
+        record(pubspec["environment"])["flutter"] !== undefined);
+export const dartPlugin = definePlugin({
+    apiVersion: 1,
+    name: "dart",
+    options: optionsSchema,
+    schemes: { flutter },
+    discover: (ctx) => pubspecRoots(ctx).map((root) => {
+        const pubspec = readPubspec(ctx, root) ?? {};
+        const packageName = pubspec["name"];
+        const { buildOffset } = ctx.options;
+        return {
+            id: defaultUnitId(root, ctx.repo.name),
+            root,
+            version: "file",
+            scheme: isFlutterApp(pubspec) ? "flutter" : "semver",
+            meta: {
+                ...(typeof packageName === "string" && { packageName }),
+                ...(buildOffset !== undefined && { buildOffset }),
+            },
+        };
+    }),
+    edges: (ctx, units) => {
+        const byName = unitsByPackage(units, "dart");
+        const edges = [];
+        for (const to of byName.values()) {
+            const pubspec = readPubspec(ctx, to.root) ?? {};
+            for (const field of DEP_FIELDS) {
+                for (const [name, spec] of Object.entries(record(pubspec[field]))) {
+                    if (typeof record(spec)["path"] === "string") {
+                        edges.push(...edgeBetween(byName.get(name), to, {
+                            reason: `${field}: ${name}`,
+                            pinned: false,
+                        }));
+                    }
+                }
+            }
+        }
+        return edges;
+    },
+    versionFiles: (_ctx, unit) => [
+        {
+            path: joinRoot(unit.root, PUBSPEC),
+            read: (content) => VERSION_LINE.exec(content)?.[3],
+            // A pubspec without a version line gets one after `name:`.
+            write: (content, next) => VERSION_LINE.test(content)
+                ? content.replace(VERSION_LINE, (_, key, quote) => `${key}${quote}${next}${quote}`)
+                : content.replace(/^name:.*$/m, (line) => `${line}\nversion: ${next}`),
+        },
+    ],
+    inputs: () => ({ global: ["pubspec.lock"] }),
+});

package/dist/go/plugin.d.ts

@@ -0,0 +1 @@
+export declare const goPlugin: import("@tallyrelease/core").Plugin<unknown>;

package/dist/go/plugin.js

@@ -0,0 +1,118 @@
+import { defaultUnitId, definePlugin } from "@tallyrelease/core";
+import { edgeBetween } from "../_kit/edges.js";
+import { joinRoot, rootOf } from "../_kit/paths.js";
+const GO_MOD = "go.mod";
+const MODULE = /^module\s+"?([^\s"]+)"?/;
+const MAJOR_SUFFIX = /\/v(\d+)$/;
+const LOCAL = /^\.{1,2}(\/|$)/;
+const readGoMod = (ctx, root) => ctx.fs.read(joinRoot(root, GO_MOD));
+/** `go.mod` lines without comments and blank lines. */
+const lines = (source) => source
+    .split("\n")
+    .map((line) => line.replace(/\/\/.*$/, "").trim())
+    .filter((line) => line !== "");
+const modulePath = (source) => {
+    for (const line of lines(source)) {
+        const match = MODULE.exec(line);
+        if (match) {
+            return match[1];
+        }
+    }
+    return undefined;
+};
+/** Relative targets of `replace` directives, single-line and block form. */
+const replaceTargets = (source) => {
+    const targets = [];
+    let block = false;
+    for (const line of lines(source)) {
+        let spec;
+        if (block) {
+            if (line === ")") {
+                block = false;
+            }
+            else {
+                spec = line;
+            }
+        }
+        else if (/^replace\s*\(/.test(line)) {
+            block = true;
+        }
+        else if (line.startsWith("replace ")) {
+            spec = line.slice("replace ".length);
+        }
+        const [from, to] = spec?.split("=>") ?? [];
+        const module = from?.trim().split(/\s+/)[0]?.replaceAll('"', "");
+        const path = to?.trim().split(/\s+/)[0]?.replaceAll('"', "");
+        if (module && path && LOCAL.test(path)) {
+            targets.push({ module, path });
+        }
+    }
+    return targets;
+};
+/** Joins `rel` onto `root` and normalizes; undefined when it leaves the repo. */
+const resolve = (root, rel) => {
+    const out = [];
+    for (const part of [...root.split("/"), ...rel.split("/")]) {
+        if (part === "..") {
+            if (out.pop() === undefined) {
+                return undefined;
+            }
+        }
+        else if (part !== "" && part !== ".") {
+            out.push(part);
+        }
+    }
+    return out.length === 0 ? "." : out.join("/");
+};
+/** Throws `E_GO_MAJOR_PATH` for the first unit whose module path lacks the `/v<major>` suffix of its next version. */
+const checkMajorPaths = (ctx, plan) => {
+    for (const unit of plan.units) {
+        if (unit.plugin !== "go" || unit.next === null) {
+            continue;
+        }
+        const major = Number.parseInt(unit.next, 10);
+        const path = modulePath(readGoMod(ctx, unit.path) ?? "");
+        if (path === undefined) {
+            continue;
+        }
+        const suffix = Number(MAJOR_SUFFIX.exec(path)?.[1] ?? 0);
+        if (major >= 2 ? suffix !== major : suffix >= 2) {
+            throw new Error(`E_GO_MAJOR_PATH: unit "${unit.id}" releases ${unit.next} but module path "${path}" ${major >= 2 ? `must end in "/v${String(major)}"` : "must not end in a /vN suffix"}`);
+        }
+    }
+};
+export const goPlugin = definePlugin({
+    apiVersion: 1,
+    name: "go",
+    discover: (ctx) => {
+        const roots = new Set(ctx.fs
+            .glob([GO_MOD, `**/${GO_MOD}`])
+            .map((p) => (p === GO_MOD ? "." : rootOf(p, GO_MOD))));
+        return [...roots].map((root) => {
+            const module = modulePath(readGoMod(ctx, root) ?? "");
+            return {
+                id: defaultUnitId(root, ctx.repo.name),
+                root,
+                version: "tag",
+                tagFormat: root === "." ? "v{version}" : `${root}/v{version}`,
+                meta: module === undefined ? {} : { modulePath: module },
+            };
+        });
+    },
+    edges: (ctx, units) => {
+        const owned = units.filter((u) => u.plugin === "go");
+        const byRoot = new Map(owned.map((u) => [u.root, u]));
+        const edges = [];
+        for (const to of owned) {
+            for (const { module, path } of replaceTargets(readGoMod(ctx, to.root) ?? "")) {
+                const target = resolve(to.root, path);
+                edges.push(...edgeBetween(target === undefined ? undefined : byRoot.get(target), to, {
+                    reason: `replace: ${module}`,
+                    pinned: false,
+                }));
+            }
+        }
+        return edges;
+    },
+    validate: checkMajorPaths,
+});

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { builtinPlugins } from "./builtin.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { builtinPlugins } from "./builtin.js";

package/dist/kustomize/plugin.d.ts

@@ -0,0 +1,3 @@
+export declare const kustomizePlugin: import("@tallyrelease/core").Plugin<{
+    paths?: string[] | undefined;
+}>;

package/dist/kustomize/plugin.js

@@ -0,0 +1,170 @@
+import { defaultUnitId, definePlugin } from "@tallyrelease/core";
+import { parse as parseYaml } from "yaml";
+import { z } from "zod";
+import { edgeBetween } from "../_kit/edges.js";
+import { globIn } from "../_kit/paths.js";
+const optionsSchema = z.strictObject({
+    paths: z.array(z.string()).optional(),
+});
+const FILE_NAMES = ["kustomization.yaml", "kustomization.yml", "Kustomization"];
+const GLOB_META = /[[\]{}()!*?+@\\]/g;
+const REMOTE = /:\/\/|^git@|^github\.com\/|\?ref=/;
+const escapeGlob = (path) => path.replace(GLOB_META, "\\$&");
+const list = (value) => (Array.isArray(value) ? value : []);
+const strings = (value) => list(value).filter((v) => typeof v === "string");
+const objects = (value) => list(value).filter((v) => typeof v === "object" && v !== null);
+/** Joins `rel` onto `root` and normalizes; undefined when it leaves the repo. */
+const resolve = (root, rel) => {
+    const out = [];
+    for (const part of [...root.split("/"), ...rel.split("/")]) {
+        if (part === "..") {
+            if (out.pop() === undefined) {
+                return undefined;
+            }
+        }
+        else if (part !== "" && part !== ".") {
+            out.push(part);
+        }
+    }
+    return out.length === 0 ? "." : out.join("/");
+};
+const isInside = (path, root) => root === "." || path === root || path.startsWith(`${root}/`);
+/** Local path references of a kustomization, relative to its directory. */
+const extractRefs = (k) => {
+    const refs = [];
+    const add = (field, path, optional) => {
+        if (typeof path === "string" && path !== "") {
+            refs.push(optional ? { field, path, optional } : { field, path });
+        }
+    };
+    // Entries with a newline are inline YAML, not paths.
+    const addPaths = (field, value) => {
+        for (const path of strings(value).filter((s) => !s.includes("\n"))) {
+            add(field, path);
+        }
+    };
+    for (const field of [
+        "resources",
+        "bases",
+        "components",
+        "crds",
+        "patchesStrategicMerge",
+        "configurations",
+        "transformers",
+        "generators",
+        "validators",
+    ]) {
+        addPaths(field, k[field]);
+    }
+    for (const field of ["patches", "patchesJson6902", "replacements"]) {
+        for (const entry of objects(k[field])) {
+            add(`${field}.path`, entry["path"]);
+        }
+    }
+    add("openapi.path", k["openapi"]?.["path"]);
+    for (const field of ["configMapGenerator", "secretGenerator"]) {
+        for (const gen of objects(k[field])) {
+            for (const file of strings(gen["files"])) {
+                add(`${field}.files`, file.replace(/^[^=]*=/, ""));
+            }
+            addPaths(`${field}.envs`, gen["envs"]);
+            add(`${field}.env`, gen["env"]);
+        }
+    }
+    const charts = objects(k["helmCharts"]);
+    for (const chart of charts) {
+        add("helmCharts.valuesFile", chart["valuesFile"]);
+        addPaths("helmCharts.additionalValuesFiles", chart["additionalValuesFiles"]);
+    }
+    if (charts.length > 0) {
+        const globals = k["helmGlobals"];
+        const home = globals?.["chartHome"];
+        add("helmGlobals.chartHome", typeof home === "string" ? home : "charts", true);
+    }
+    return refs;
+};
+const readKustomization = (ctx, root, file) => {
+    try {
+        const doc = parseYaml(ctx.fs.read(file) ?? "");
+        return typeof doc === "object" && doc !== null
+            ? doc
+            : {};
+    }
+    catch (error) {
+        ctx.log.warn(`${root}: cannot parse ${file}: ${String(error)}`);
+        return {};
+    }
+};
+const unitId = (root, repoName) => root === "." ? defaultUnitId(root, repoName) : root.replaceAll("/", "-");
+export const kustomizePlugin = definePlugin({
+    apiVersion: 1,
+    name: "kustomize",
+    options: optionsSchema,
+    discover: (ctx) => {
+        const paths = ctx.options.paths ?? ["**"];
+        const files = new Map();
+        for (const file of ctx.fs.glob(paths.flatMap((p) => FILE_NAMES.map((name) => globIn(p, name))))) {
+            const root = file.includes("/")
+                ? file.slice(0, file.lastIndexOf("/"))
+                : ".";
+            if (!files.has(root)) {
+                files.set(root, file);
+            }
+        }
+        const roots = new Set(files.keys());
+        return [...files].map(([root, file]) => {
+            const refs = [];
+            const extra = new Set();
+            for (const ref of extractRefs(readKustomization(ctx, root, file))) {
+                if (REMOTE.test(ref.path) || ref.path.startsWith("/")) {
+                    continue;
+                }
+                const target = resolve(root, ref.path);
+                if (target === undefined) {
+                    ctx.log.warn(`${root}: ${ref.field} "${ref.path}" leaves the repository`);
+                }
+                else if (target === root) {
+                    continue;
+                }
+                else if (roots.has(target)) {
+                    refs.push({ path: ref.path, field: ref.field });
+                }
+                else if (isInside(target, root)) {
+                    continue;
+                }
+                else if (ref.optional || ctx.fs.exists(target)) {
+                    extra.add(escapeGlob(target));
+                    extra.add(`${escapeGlob(target)}/**`);
+                }
+                else {
+                    ctx.log.warn(`${root}: ${ref.field} "${ref.path}" does not exist`);
+                }
+            }
+            return {
+                id: unitId(root, ctx.repo.name),
+                root,
+                ...(extra.size > 0 && {
+                    include: [root === "." ? "**" : `${escapeGlob(root)}/**`, ...extra],
+                }),
+                meta: { refs },
+            };
+        });
+    },
+    edges: (_ctx, units) => {
+        const own = units.filter((u) => u.plugin === "kustomize");
+        const byRoot = new Map(own.map((u) => [u.root, u]));
+        const edges = [];
+        for (const to of own) {
+            const refs = (to.meta["kustomize"]?.["refs"] ?? []);
+            for (const { path, field } of refs) {
+                const target = resolve(to.root, path);
+                const from = target === undefined ? undefined : byRoot.get(target);
+                edges.push(...edgeBetween(from, to, {
+                    reason: `${field}: ${path}`,
+                    pinned: false,
+                }));
+            }
+        }
+        return edges;
+    },
+});

package/dist/node/plugin.d.ts

@@ -0,0 +1 @@
+export declare const nodePlugin: import("@tallyrelease/core").Plugin<unknown>;

package/dist/node/plugin.js

@@ -0,0 +1,120 @@
+import { defaultUnitId, definePlugin } from "@tallyrelease/core";
+import { parse as parseYaml } from "yaml";
+import { dependencyEdges, unitsByPackage } from "../_kit/edges.js";
+import { parseJson, readManifest } from "../_kit/manifest.js";
+import { globIn, joinRoot, rootOf } from "../_kit/paths.js";
+import { BUILD, NUMBERS, PRERELEASE } from "../_kit/semver.js";
+const PINNED_FIELDS = ["dependencies", "optionalDependencies"];
+const UNPINNED_FIELDS = ["peerDependencies", "devDependencies"];
+const EXACT = new RegExp(`^(workspace:)?(\\*|=?v?${NUMBERS}${PRERELEASE}${BUILD})$`);
+/** Pinned version ranges rewritten on release; the prefix is kept. */
+const PINNED_VERSION = new RegExp(`^((?:workspace:)?=?v?)${NUMBERS}${PRERELEASE}${BUILD}$`);
+const MANIFEST = "package.json";
+const manifestPath = (root) => joinRoot(root, MANIFEST);
+const readPackage = (ctx, root) => readManifest(ctx, root, MANIFEST);
+/** Workspace globs from `pnpm-workspace.yaml` or `package.json`, if any. */
+const workspacePatterns = (ctx) => {
+    const pnpm = ctx.fs.read("pnpm-workspace.yaml");
+    if (pnpm !== undefined) {
+        const doc = parseYaml(pnpm);
+        return doc?.packages ?? [];
+    }
+    const { workspaces } = readPackage(ctx, ".") ?? {};
+    if (workspaces === undefined) {
+        return undefined;
+    }
+    return Array.isArray(workspaces) ? workspaces : (workspaces.packages ?? []);
+};
+const packageRoots = (ctx, patterns) => {
+    const manifests = (list) => ctx.fs.glob(list.map((p) => globIn(p, MANIFEST)));
+    const excluded = new Set(manifests(patterns.filter((p) => p.startsWith("!")).map((p) => p.slice(1))));
+    return manifests(patterns.filter((p) => !p.startsWith("!")))
+        .filter((p) => !excluded.has(p))
+        .map((p) => rootOf(p, MANIFEST));
+};
+export const nodePlugin = definePlugin({
+    apiVersion: 1,
+    name: "node",
+    discover: (ctx) => {
+        const patterns = workspacePatterns(ctx);
+        const roots = patterns === undefined
+            ? ctx.fs.exists("package.json")
+                ? ["."]
+                : []
+            : packageRoots(ctx, patterns);
+        return roots.map((root) => {
+            const packageName = readPackage(ctx, root)?.name;
+            return {
+                id: defaultUnitId(root, ctx.repo.name),
+                root,
+                version: "file",
+                meta: packageName === undefined ? {} : { packageName },
+            };
+        });
+    },
+    edges: (ctx, units) => {
+        const byName = unitsByPackage(units, "node", (name, prior, unit) => {
+            ctx.log.warn(`package "${name}" is declared by "${prior.root}" and "${unit.root}"; using "${unit.root}"`);
+        });
+        const edges = [];
+        for (const to of byName.values()) {
+            const manifest = readPackage(ctx, to.root) ?? {};
+            const fields = [
+                ...PINNED_FIELDS.map((field) => [field, EXACT]),
+                ...UNPINNED_FIELDS.map((field) => [field, undefined]),
+            ];
+            for (const [field, exact] of fields) {
+                const deps = (manifest[field] ?? {});
+                edges.push(...dependencyEdges(byName, to, { field, deps, exact }));
+            }
+        }
+        return edges;
+    },
+    versionFiles: (_ctx, unit) => [
+        {
+            path: manifestPath(unit.root),
+            read: (content) => {
+                const { version } = parseJson(manifestPath(unit.root), content);
+                return typeof version === "string" ? version : undefined;
+            },
+            write: (content, next, { units, versions }) => {
+                const manifest = parseJson(manifestPath(unit.root), content);
+                manifest["version"] = next;
+                const released = new Map();
+                for (const u of units) {
+                    const name = u.meta["node"]?.["packageName"];
+                    const version = versions.get(u.id);
+                    if (typeof name === "string" && version !== undefined) {
+                        released.set(name, version);
+                    }
+                }
+                for (const field of PINNED_FIELDS) {
+                    const deps = (manifest[field] ?? {});
+                    for (const [name, range] of Object.entries(deps)) {
+                        const version = released.get(name);
+                        const prefix = PINNED_VERSION.exec(range)?.[1];
+                        if (version !== undefined && prefix !== undefined) {
+                            deps[name] = `${prefix}${version}`;
+                        }
+                    }
+                }
+                const indent = /^([ \t]+)"/m.exec(content)?.[1] ?? "  ";
+                const text = `${JSON.stringify(manifest, null, indent)}${content.endsWith("\n") ? "\n" : ""}`;
+                return content.includes("\r\n") ? text.replaceAll("\n", "\r\n") : text;
+            },
+        },
+    ],
+    inputs: (ctx) => ({
+        global: [
+            "yarn.lock",
+            "package-lock.json",
+            "pnpm-lock.yaml",
+            "pnpm-workspace.yaml",
+            ".yarnrc.yml",
+            ".yarn/patches/**",
+            ...(workspacePatterns(ctx) === undefined ? [] : ["package.json"]),
+            "tsconfig*.json",
+            "turbo.json",
+        ],
+    }),
+});

package/dist/php/plugin.d.ts

@@ -0,0 +1 @@
+export declare const phpPlugin: import("@tallyrelease/core").Plugin<unknown>;

package/dist/php/plugin.js

@@ -0,0 +1,59 @@
+import { defaultUnitId, definePlugin } from "@tallyrelease/core";
+import { dependencyEdges, unitsByPackage } from "../_kit/edges.js";
+import { readManifest } from "../_kit/manifest.js";
+import { globIn, rootOf } from "../_kit/paths.js";
+import { NUMBERS, PRERELEASE } from "../_kit/semver.js";
+const EXACT = new RegExp(`^(self\\.version|=?v?${NUMBERS}(\\.\\d+)?${PRERELEASE})$`);
+const COMPOSER = "composer.json";
+const readComposer = (ctx, root) => readManifest(ctx, root, COMPOSER);
+/** Local `repositories[type=path]` url globs, repo-relative. */
+const pathRepoGlobs = (composer) => {
+    const repos = Object.values((composer.repositories ?? {}));
+    return repos
+        .filter((r) => r.type === "path" && typeof r.url === "string")
+        .map((r) => (r.url ?? "").replace(/^\.\//, "").replace(/\/+$/, ""))
+        .filter((url) => url !== "" && !url.startsWith("../"));
+};
+export const phpPlugin = definePlugin({
+    apiVersion: 1,
+    name: "php",
+    discover: (ctx) => {
+        const rootComposer = readComposer(ctx, ".");
+        if (!rootComposer) {
+            return [];
+        }
+        const roots = [
+            ".",
+            ...ctx.fs
+                .glob(pathRepoGlobs(rootComposer).map((u) => globIn(u, COMPOSER)))
+                .map((p) => rootOf(p, COMPOSER))
+                .filter((root) => root !== ""),
+        ];
+        return roots.map((root) => {
+            const packageName = readComposer(ctx, root)?.name;
+            return {
+                id: defaultUnitId(root, ctx.repo.name),
+                root,
+                version: "tag",
+                meta: packageName === undefined ? {} : { packageName },
+            };
+        });
+    },
+    edges: (ctx, units) => {
+        const byName = unitsByPackage(units, "php");
+        const edges = [];
+        for (const to of byName.values()) {
+            const composer = readComposer(ctx, to.root) ?? {};
+            for (const field of ["require", "require-dev"]) {
+                const deps = (composer[field] ?? {});
+                edges.push(...dependencyEdges(byName, to, {
+                    field,
+                    deps,
+                    exact: field === "require" ? EXACT : undefined,
+                }));
+            }
+        }
+        return edges;
+    },
+    inputs: () => ({ global: ["composer.lock"] }),
+});

package/package.json

@@ -1,6 +1,74 @@
 {
   "name": "@tallyrelease/plugins",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.0",
+  "description": "Built-in ecosystem plugins of tallyrelease",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/abinnovision/tallyrelease.git",
+    "directory": "packages/plugins"
+  },
+  "license": "Apache-2.0",
+  "author": {
+    "name": "abi group GmbH",
+    "email": "info@abigroup.io",
+    "url": "https://abigroup.io"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc --build tsconfig.build.json",
+    "check:purity": "node ../../tools/check-purity.mjs src/index.ts",
+    "format:check": "prettier --check '{{src,test}/**/*,*}.{{t,j}s{,x},json{,5},md,y{,a}ml,css,html,gql,graphql}'",
+    "format:fix": "prettier --write '{{src,test}/**/*,*}.{{t,j}s{,x},json{,5},md,y{,a}ml,css,html,gql,graphql}'",
+    "lint:check": "eslint '{{src,test}/**/*,*}.{t,j}s{,x}'",
+    "lint:fix": "eslint '{{src,test}/**/*,*}.{t,j}s{,x}' --fix",
+    "test-unit": "vitest --passWithNoTests --run --coverage --config vitest.config.ts --project='*#unit'",
+    "test-unit:watch": "vitest --passWithNoTests --config vitest.config.ts --project='*#unit'",
+    "typecheck": "tsc -p tsconfig.json"
+  },
+  "lint-staged": {
+    "{{src,test}/**/*,*}.{{t,j}s{,x},json{,5},md,y{,a}ml,css,html,gql,graphql}": "prettier --write",
+    "{{src,test}/**/*,*}.{t,j}s{,x}": "eslint --fix"
+  },
+  "prettier": "@abinnovision/prettier-config",
+  "dependencies": {
+    "@tallyrelease/core": "^0.4.1",
+    "yaml": "^2.9.1",
+    "zod": "^4.6.7"
+  },
+  "devDependencies": {
+    "@abinnovision/eslint-config-base": "^3.4.2",
+    "@abinnovision/prettier-config": "^2.2.0",
+    "@internal/tsconfig": "0.0.0",
+    "@types/node": "^26.6.5",
+    "@vitest/coverage-v8": "^5.0.5",
+    "eslint": "^10.13.0",
+    "prettier": "^3.9.10",
+    "typescript": "^6.0.3",
+    "vite": "^8.3.5",
+    "vitest": "^5.0.5"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js",
+        "default": "./dist/index.js"
+      }
+    },
+    "npm": true
+  }
 }