@a2f0/agent-tool 0.1.5 → 0.1.7

package/README.md

@@ -143,6 +143,7 @@ feature checkout with policy from a trusted source.
   },
   "versions": {
     "packages": ["packages/api", "packages/client"],
+    "bundles": ["packages/client"],
     "lockfile": "bun.lock",
     "validate": [["bun", "run", "lint", "--", "--staged"]],
     "commitMessage": "chore: bump package versions"
@@ -172,6 +173,14 @@ including files in other configured packages. A changed package moves one patch
 past the base; a deliberate major or minor bump is kept. `plan`, `bump`, and
 `check` neither regenerate lockfiles nor commit.
 
+`versions.bundles` names versioned packages whose published artifact includes
+the workspace packages they depend on. Such a package also counts as changed
+when any workspace package it reaches through `workspace:` ranges in
+`dependencies` changes, directly or transitively; an alias range such as
+`workspace:crypto@*` names its target. `devDependencies` and
+`peerDependencies` do not count. A bundled package whose only change is its
+version does not move the bundle.
+
 `versions prepare` runs the whole sequence before a review snapshot:
 
 1. It requires a clean worktree on an attached branch with the exact base

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a2f0/agent-tool",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "type": "module",
   "description": "Portable cross-agent review, PR workflows, and shared skills",
   "license": "UNLICENSED",

package/src/config.ts

@@ -11,7 +11,7 @@ export interface AgentToolConfig {
   subject: { conventional: boolean; maxLength: number; types: string[] };
   merge: { requireChecks: boolean; requiredChecks: RequiredCheck[]; requireStrictBaseFreshness: boolean };
   review: { claudeModel: string | null; codexModel: string | null; opencodeModel: string; opencodeVariants: Record<string, string>; timeoutMs: number };
-  versions: { packages: string[] | null; lockfile: "bun.lock" | null; validate: string[][]; commitMessage: string };
+  versions: { packages: string[] | null; bundles: string[]; lockfile: "bun.lock" | null; validate: string[][]; commitMessage: string };
   pr: { rejectClaudeBranding: boolean };
 }
 
@@ -24,7 +24,7 @@ export const DEFAULT_CONFIG: AgentToolConfig = {
   },
   merge: { requireChecks: true, requiredChecks: [], requireStrictBaseFreshness: false },
   review: { claudeModel: null, codexModel: null, opencodeModel: "deepseek/deepseek-v4-pro", opencodeVariants: { low: "low", medium: "medium", high: "high", xhigh: "max", max: "max" }, timeoutMs: 600_000 },
-  versions: { packages: null, lockfile: "bun.lock", validate: [], commitMessage: "chore: bump package versions" },
+  versions: { packages: null, bundles: [], lockfile: "bun.lock", validate: [], commitMessage: "chore: bump package versions" },
   pr: { rejectClaudeBranding: false },
 };
 
@@ -77,9 +77,9 @@ export function parseConfig(source: string): AgentToolConfig {
   for (const value of Object.values(variants)) if (typeof value !== "string" || !/^[^\s]+$/.test(value)) invalid("review.opencodeVariants");
   if (typeof result.review.opencodeModel !== "string" || !/^[^\s/]+\/[^\s]+$/.test(result.review.opencodeModel)) invalid("review.opencodeModel");
   if (!Number.isSafeInteger(result.review.timeoutMs) || result.review.timeoutMs < 1000 || result.review.timeoutMs > 3_600_000) invalid("review.timeoutMs");
-  if (result.versions.packages !== null) {
-    if (!strings(result.versions.packages) || result.versions.packages.some(dir => dir !== "." && (path.isAbsolute(dir) || dir.includes("\\") || dir.split("/").some(part => !part || part === "." || part === "..")))) invalid("versions.packages");
-  }
+  const packageDirs = (dirs: unknown): boolean => strings(dirs) && !dirs.some(dir => dir !== "." && (path.isAbsolute(dir) || dir.includes("\\") || dir.split("/").some(part => !part || part === "." || part === "..")));
+  if (result.versions.packages !== null && !packageDirs(result.versions.packages)) invalid("versions.packages");
+  if (!packageDirs(result.versions.bundles)) invalid("versions.bundles");
   if (result.versions.lockfile !== null && result.versions.lockfile !== "bun.lock") invalid("versions.lockfile");
   // Commands are argv arrays resolved on PATH outside the repository; no shell.
   if (!Array.isArray(result.versions.validate) || result.versions.validate.some(command => !strings(command) || command.length === 0 || !/^[\w.+-]+$/.test(command[0]!))) invalid("versions.validate");

package/src/version/bumpVersions.ts

@@ -3,6 +3,7 @@ import { execFileSync, spawnSync } from "node:child_process";
 import { lstatSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
 
+import { bundledPackages } from "./bundledPackages";
 import {
   bumpPatch,
   isReleaseBump,
@@ -58,18 +59,12 @@ function resolveBaseCommit(
   return git(rootDir, ["rev-parse", "--verify", `${oid}^{commit}`]).trim();
 }
 
-/**
- * Whether the branch changes the package, counting its manifest only for edits
- * beyond the version field.
- */
-function packageChanged(
+function changedFiles(
   rootDir: string,
   mergeBase: string,
   packageDir: string,
-  headManifest: string,
-): boolean {
-  const manifest = manifestPath(packageDir);
-  const changed = git(rootDir, [
+): string[] {
+  return git(rootDir, [
     "diff",
     "--name-only",
     "--no-renames",
@@ -81,6 +76,20 @@ function packageChanged(
   ])
     .split("\0")
     .filter(Boolean);
+}
+
+/**
+ * Whether the branch changes the package, counting its manifest only for edits
+ * beyond the version field.
+ */
+function packageChanged(
+  rootDir: string,
+  mergeBase: string,
+  packageDir: string,
+  headManifest: string,
+): boolean {
+  const manifest = manifestPath(packageDir);
+  const changed = changedFiles(rootDir, mergeBase, packageDir);
   if (changed.some((file) => file !== manifest)) {
     return true;
   }
@@ -98,10 +107,40 @@ function packageChanged(
   return withVersion(mergeBaseManifest, version) !== headManifest;
 }
 
+/** A manifest's fields other than `version`, in a comparable form. */
+function withoutVersion(manifest: string | null): string | null {
+  if (manifest === null) return null;
+  const parsed: unknown = JSON.parse(manifest);
+  if (typeof parsed === "object" && parsed !== null) {
+    Reflect.deleteProperty(parsed, "version");
+  }
+  return JSON.stringify(parsed);
+}
+
+/**
+ * Whether the branch changes a package a bundle ships, beyond its version.
+ * The package need not be versioned, so its version is never parsed.
+ */
+function bundledPackageChanged(
+  rootDir: string,
+  mergeBase: string,
+  packageDir: string,
+): boolean {
+  const manifest = manifestPath(packageDir);
+  const changed = changedFiles(rootDir, mergeBase, packageDir);
+  if (changed.some((file) => file !== manifest)) return true;
+  if (!changed.includes(manifest)) return false;
+  return (
+    withoutVersion(showFile(rootDir, mergeBase, manifest)) !==
+    withoutVersion(showFile(rootDir, "HEAD", manifest))
+  );
+}
+
 /**
  * The version each package should carry at HEAD to merge onto `baseCommit`:
- * one patch past the base when the branch changes the package, the base's own
- * version when it does not, and a deliberate major or minor bump left alone.
+ * one patch past the base when the branch changes the package or a package it
+ * bundles, the base's own version when it does not, and a deliberate major or
+ * minor bump left alone.
  */
 export function planVersions(
   rootDir: string,
@@ -109,6 +148,16 @@ export function planVersions(
 ): VersionPlan[] {
   const baseCommit = resolveBaseCommit(rootDir, baseOid);
   const mergeBase = git(rootDir, ["merge-base", baseCommit, "HEAD"]).trim();
+  const bundles = bundledPackages(rootDir);
+  const bundledChanges = new Map<string, boolean>();
+  const bundledChanged = (packageDir: string): boolean => {
+    let result = bundledChanges.get(packageDir);
+    if (result === undefined) {
+      result = bundledPackageChanged(rootDir, mergeBase, packageDir);
+      bundledChanges.set(packageDir, result);
+    }
+    return result;
+  };
   const plans: VersionPlan[] = [];
   for (const packageDir of workspacePackages(rootDir)) {
     const manifest = manifestPath(packageDir);
@@ -127,7 +176,10 @@ export function planVersions(
     let targetVersion = baseVersion;
     if (isReleaseBump(headVersion, baseVersion)) {
       targetVersion = headVersion;
-    } else if (packageChanged(rootDir, mergeBase, packageDir, headManifest)) {
+    } else if (
+      packageChanged(rootDir, mergeBase, packageDir, headManifest) ||
+      (bundles.get(packageDir) ?? []).some(bundledChanged)
+    ) {
       targetVersion = bumpPatch(baseVersion);
     }
     plans.push({ manifest, baseVersion, headVersion, targetVersion });

package/src/version/bundledPackages.ts

@@ -0,0 +1,83 @@
+import { gitEnvironment } from "../git/environment";
+import { spawnSync } from "node:child_process";
+import { loadConfig } from "../config";
+import {
+  discoveredWorkspaces,
+  manifestPath,
+  workspacePackages,
+} from "./packageVersion";
+
+interface WorkspaceManifest {
+  name?: unknown;
+  dependencies?: unknown;
+}
+
+function headManifest(rootDir: string, packageDir: string): WorkspaceManifest {
+  const file = manifestPath(packageDir);
+  const result = spawnSync("git", ["show", `HEAD:${file}`], {
+    cwd: rootDir,
+    env: gitEnvironment(),
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) throw new Error(`${file} is not committed at HEAD.`);
+  return JSON.parse(result.stdout);
+}
+
+/**
+ * The workspace packages a manifest depends on at runtime through `workspace:`
+ * ranges. An alias range such as `workspace:crypto@*` names its target.
+ */
+function workspaceDependencies(manifest: WorkspaceManifest): string[] {
+  const { dependencies } = manifest;
+  if (typeof dependencies !== "object" || dependencies === null) return [];
+  return Object.entries(dependencies).flatMap(([name, range]) => {
+    if (typeof range !== "string" || !range.startsWith("workspace:")) return [];
+    const alias = /^((?:@[^/@]+\/)?[^/@]+)@/.exec(range.slice("workspace:".length));
+    return [alias?.[1] ?? name];
+  });
+}
+
+/**
+ * The workspace packages each configured bundle ships inside its own artifact:
+ * every package it reaches through `workspace:` ranges in `dependencies`, read
+ * from HEAD. A change to any of them is a change to the bundle.
+ */
+export function bundledPackages(rootDir: string): Map<string, string[]> {
+  const bundles = loadConfig(rootDir).versions.bundles;
+  const result = new Map<string, string[]>();
+  if (bundles.length === 0) return result;
+  const versioned = workspacePackages(rootDir);
+  // Discovered only when a bundle has a workspace dependency, so a bundle
+  // without any needs no workspace declaration.
+  let directories: Map<string, string> | undefined;
+  const directoryOf = (name: string): string | undefined => {
+    if (directories === undefined) {
+      directories = new Map();
+      for (const packageDir of discoveredWorkspaces(rootDir)) {
+        const manifest = headManifest(rootDir, packageDir);
+        if (typeof manifest.name === "string") directories.set(manifest.name, packageDir);
+      }
+    }
+    return directories.get(name);
+  };
+  for (const bundle of bundles) {
+    if (!versioned.includes(bundle)) {
+      throw new Error(`versions.bundles names ${bundle}, which is not a versioned package.`);
+    }
+    const reached = new Set<string>();
+    const pending = workspaceDependencies(headManifest(rootDir, bundle));
+    for (let name = pending.pop(); name !== undefined; name = pending.pop()) {
+      const packageDir = directoryOf(name);
+      if (packageDir === undefined) {
+        throw new Error(`${bundle} depends on ${name}, which is not a workspace package.`);
+      }
+      if (packageDir === bundle || reached.has(packageDir)) continue;
+      reached.add(packageDir);
+      pending.push(...workspaceDependencies(headManifest(rootDir, packageDir)));
+    }
+    result.set(bundle, [...reached].sort());
+  }
+  return result;
+}

package/src/version/packageVersion.ts

@@ -6,10 +6,14 @@ import {
 import { posix } from "node:path";
 import { loadConfig } from "../config";
 
-/** Discover every committed workspace, including globbed and newly added ones. */
+/** The versioned packages: the configured directories, or every workspace. */
 export function workspacePackages(rootDir: string): string[] {
   const configured = loadConfig(rootDir).versions.packages;
-  if (configured !== null) return [...configured];
+  return configured === null ? discoveredWorkspaces(rootDir) : [...configured];
+}
+
+/** Discover every committed workspace, including globbed and newly added ones. */
+export function discoveredWorkspaces(rootDir: string): string[] {
   const options: ExecFileSyncOptionsWithStringEncoding = {
     cwd: rootDir,
     env: gitEnvironment(),