Merge pull request #20 from syi0808/feat/multi-ecosystem-detection

feat: support multi-ecosystem detection in a single directory

Author: syi0808

packages/core/src/changeset/changelog.ts

@@ -1,3 +1,4 @@
+import { packageKey } from "../utils/package-key.js";
 import type { BumpType, Changeset } from "./parser.js";
 
 export { writeChangelogToFile } from "../changelog/file.js";
@@ -74,13 +75,16 @@ export function deduplicateEntries(
 
 export function buildChangelogEntries(
   changesets: Changeset[],
-  packagePath: string,
+  targetKey: string,
 ): ChangelogEntry[] {
   const entries: ChangelogEntry[] = [];
 
   for (const changeset of changesets) {
     for (const release of changeset.releases) {
-      if (release.path === packagePath) {
+      const releaseKey = release.ecosystem
+        ? packageKey({ path: release.path, ecosystem: release.ecosystem })
+        : release.path;
+      if (releaseKey === targetKey || release.path === targetKey) {
         entries.push({
           summary: changeset.summary,
           type: release.type,

packages/core/src/changeset/parser.ts

@@ -1,9 +1,11 @@
 import { parse as parseYaml } from "yaml";
+import type { EcosystemKey } from "../ecosystem/catalog.js";
 
 export type BumpType = "patch" | "minor" | "major";
 
 export interface Release {
   path: string;
+  ecosystem?: EcosystemKey;
   type: BumpType;
 }
 
@@ -43,8 +45,26 @@ export function parseChangeset(
           `Invalid bump type "${type}" for package "${key}" in "${fileName}". Expected: patch, minor, or major.`,
         );
       }
-      const path = resolveKey ? resolveKey(key) : key;
-      releases.push({ path, type: type as BumpType });
+      const resolvedKey = resolveKey ? resolveKey(key) : key;
+
+      // Parse path::ecosystem format
+      const separatorIndex = resolvedKey.lastIndexOf("::");
+      let releasePath: string;
+      let ecosystem: EcosystemKey | undefined;
+      if (separatorIndex !== -1) {
+        releasePath = resolvedKey.slice(0, separatorIndex);
+        ecosystem = resolvedKey.slice(separatorIndex + 2);
+        if (!releasePath || !ecosystem) {
+          throw new Error(
+            `Invalid package key "${resolvedKey}" in "${fileName}". Expected "path::ecosystem" with non-empty path and ecosystem.`,
+          );
+        }
+      } else {
+        releasePath = resolvedKey;
+        ecosystem = undefined;
+      }
+
+      releases.push({ path: releasePath, ecosystem, type: type as BumpType });
     }
   }
 

packages/core/src/changeset/resolve.ts

@@ -1,15 +1,45 @@
-import type { ResolvedPackageConfig } from "../config/types.js";
+import type { EcosystemKey } from "../ecosystem/catalog.js";
+import { packageKey } from "../utils/package-key.js";
 
 export function createKeyResolver(
-  packages: Pick<ResolvedPackageConfig, "name" | "path">[],
+  packages: { name: string; path: string; ecosystem: EcosystemKey }[],
 ): (key: string) => string {
-  const nameToPath = new Map(packages.map((p) => [p.name, p.path]));
-  const validPaths = new Set(packages.map((p) => p.path));
+  const validKeys = new Set(packages.map((p) => packageKey(p)));
+  const pathEcosystems = new Map<string, EcosystemKey[]>();
+  const nameEcosystems = new Map<string, EcosystemKey[]>();
+  for (const p of packages) {
+    const existingPath = pathEcosystems.get(p.path) ?? [];
+    if (!existingPath.includes(p.ecosystem)) existingPath.push(p.ecosystem);
+    pathEcosystems.set(p.path, existingPath);
+
+    const existingName = nameEcosystems.get(p.name) ?? [];
+    if (!existingName.includes(p.ecosystem)) existingName.push(p.ecosystem);
+    nameEcosystems.set(p.name, existingName);
+  }
 
   return (key: string): string => {
-    if (validPaths.has(key)) return key;
-    const resolved = nameToPath.get(key);
-    if (resolved) return resolved;
+    if (validKeys.has(key)) return key;
+    const ecosystems = pathEcosystems.get(key);
+    if (ecosystems) {
+      if (ecosystems.length === 1) {
+        return `${key}::${ecosystems[0]}`;
+      }
+      throw new Error(
+        `Ambiguous changeset key "${key}": directory contains multiple ecosystems (${ecosystems.join(", ")}). ` +
+          `Use "${key}::${ecosystems[0]}" or "${key}::${ecosystems[1]}" to specify.`,
+      );
+    }
+    const nameEcos = nameEcosystems.get(key);
+    if (nameEcos) {
+      if (nameEcos.length === 1) {
+        const pkg = packages.find((p) => p.name === key);
+        if (pkg) return packageKey(pkg);
+      }
+      throw new Error(
+        `Ambiguous changeset key "${key}": name is shared across ecosystems (${nameEcos.join(", ")}). ` +
+          `Use the path::ecosystem format to specify.`,
+      );
+    }
     return key;
   };
 }

packages/core/src/changeset/status.ts

@@ -1,4 +1,5 @@
 import process from "node:process";
+import { packageKey } from "../utils/package-key.js";
 import { maxBump } from "./bump-utils.js";
 import type { BumpType, Changeset } from "./parser.js";
 import { readChangesets } from "./reader.js";
@@ -24,14 +25,17 @@ export function getStatus(
 
   for (const changeset of changesets) {
     for (const release of changeset.releases) {
-      const existing = packages.get(release.path);
+      const key = release.ecosystem
+        ? packageKey({ path: release.path, ecosystem: release.ecosystem })
+        : release.path;
+      const existing = packages.get(key);
 
       if (existing) {
         existing.bumpType = maxBump(existing.bumpType, release.type);
         existing.changesetCount += 1;
         existing.summaries.push(changeset.summary);
       } else {
-        packages.set(release.path, {
+        packages.set(key, {
           bumpType: release.type,
           changesetCount: 1,
           summaries: [changeset.summary],

packages/core/src/changeset/version.ts

@@ -1,5 +1,6 @@
 import process from "node:process";
 import { inc } from "semver";
+import { packageKey } from "../utils/package-key.js";
 import { maxBump } from "./bump-utils.js";
 import type { BumpType } from "./parser.js";
 import { readChangesets } from "./reader.js";
@@ -20,13 +21,16 @@ export function calculateVersionBumps(
 
   for (const changeset of changesets) {
     for (const release of changeset.releases) {
-      if (!currentVersions.has(release.path)) continue;
+      const key = release.ecosystem
+        ? packageKey({ path: release.path, ecosystem: release.ecosystem })
+        : release.path;
+      if (!currentVersions.has(key)) continue;
 
-      const existing = bumpTypes.get(release.path);
+      const existing = bumpTypes.get(key);
       if (existing) {
-        bumpTypes.set(release.path, maxBump(existing, release.type));
+        bumpTypes.set(key, maxBump(existing, release.type));
       } else {
-        bumpTypes.set(release.path, release.type);
+        bumpTypes.set(key, release.type);
       }
     }
   }

packages/core/src/changeset/writer.ts

@@ -90,7 +90,10 @@ export function generateChangesetContent(
   if (releases.length > 0) {
     const yamlObj: Record<string, string> = {};
     for (const release of releases) {
-      yamlObj[release.path] = release.type;
+      const key = release.ecosystem
+        ? `${release.path}::${release.ecosystem}`
+        : release.path;
+      yamlObj[key] = release.type;
     }
     content += stringifyYaml(yamlObj);
   }

packages/core/src/config/types.ts

@@ -1,5 +1,6 @@
 import type { CompressOption, ReleaseAssetEntry } from "../assets/types.js";
 import type { BumpType } from "../changeset/parser.js";
+import type { EcosystemKey } from "../ecosystem/catalog.js";
 import type { PubmPlugin } from "../plugin/types.js";
 import type { RegistryType } from "../types/options.js";
 
@@ -26,11 +27,12 @@ export interface PackageConfig {
 }
 
 export interface ResolvedPackageConfig
-  extends Omit<PackageConfig, "registries"> {
+  extends Omit<PackageConfig, "registries" | "ecosystem"> {
   name: string;
   version: string;
   dependencies: string[];
   registries: RegistryType[];
+  ecosystem: EcosystemKey;
   registryVersions?: Map<RegistryType, string>;
 }
 

packages/core/src/context.ts

@@ -8,7 +8,7 @@ import { RollbackTracker } from "./utils/rollback.js";
 export interface SingleVersionPlan {
   mode: "single";
   version: string;
-  packagePath: string;
+  packageKey: string;
 }
 
 export interface FixedVersionPlan {
@@ -42,15 +42,12 @@ export function resolveVersion(
   return picker(plan.packages);
 }
 
-export function getPackageVersion(
-  ctx: PubmContext,
-  packagePath: string,
-): string {
+export function getPackageVersion(ctx: PubmContext, key: string): string {
   const plan = ctx.runtime.versionPlan;
   if (plan) {
     if (plan.mode === "single") return plan.version;
     if (plan.mode === "fixed") return plan.version;
-    return plan.packages.get(packagePath) ?? "";
+    return plan.packages.get(key) ?? "";
   }
   return "";
 }

packages/core/src/ecosystem/catalog.ts

@@ -24,13 +24,14 @@ export class EcosystemCatalog {
     return this.descriptors.get(key);
   }
 
-  async detect(packagePath: string): Promise<EcosystemDescriptor | null> {
+  async detectAll(packagePath: string): Promise<EcosystemDescriptor[]> {
+    const results: EcosystemDescriptor[] = [];
     for (const descriptor of this.descriptors.values()) {
       if (await descriptor.detect(packagePath)) {
-        return descriptor;
+        results.push(descriptor);
       }
     }
-    return null;
+    return results;
   }
 
   all(): EcosystemDescriptor[] {

packages/core/src/ecosystem/index.ts

@@ -1,12 +1,18 @@
 import { ecosystemCatalog } from "./catalog.js";
 import type { Ecosystem } from "./ecosystem.js";
 
+/**
+ * Detects the ecosystem for a single package path, returning only the first
+ * detected ecosystem. This is a convenience API for single-ecosystem packages.
+ * For packages that may belong to multiple ecosystems, use
+ * `ecosystemCatalog.detectAll()` instead.
+ */
 export async function detectEcosystem(
   packagePath: string,
 ): Promise<Ecosystem | null> {
-  const detected = await ecosystemCatalog.detect(packagePath);
-  if (detected) {
-    return new detected.ecosystemClass(packagePath);
+  const detected = await ecosystemCatalog.detectAll(packagePath);
+  if (detected.length > 0) {
+    return new detected[0].ecosystemClass(packagePath);
   }
 
   return null;