intershell 0.6.1 → 0.6.3

package/src/compose/compose.test.ts

@@ -4,7 +4,7 @@ type CustomBunType = {
 	YAML: {
 		parse: (input: string) => Record<string, unknown>;
 	};
-	file: (path: string) => { text: () => string };
+	file: (path: string) => { text: () => Promise<string>; exists: () => Promise<boolean> };
 };
 
 describe("EntityCompose", () => {
@@ -55,13 +55,6 @@ describe("EntityCompose", () => {
 		originalBunFile = (Bun as unknown as CustomBunType).file;
 	});
 
-	// Restore mocks after each test
-	afterEach(() => {
-		// Restore original Bun methods
-		(Bun as unknown as CustomBunType).YAML = originalBunYaml;
-		(Bun as unknown as CustomBunType).file = originalBunFile;
-	});
-
 	// Store original methods to restore after tests
 	let originalEntityPackageGetAllPackages: () => Promise<string[]>;
 	let originalEntityAffectedGetAffectedPackages: (
@@ -104,13 +97,22 @@ describe("EntityCompose", () => {
 		}
 	};
 
+	afterEach(async () => {
+		(Bun as unknown as CustomBunType).YAML = originalBunYaml;
+		(Bun as unknown as CustomBunType).file = originalBunFile;
+		await cleanupMocks();
+	});
+
 	// Common mock setup for Bun
 	const setupBunMocks = (
 		mockYamlParse: ReturnType<typeof mock>,
 		mockFileText: ReturnType<typeof mock>,
 	) => {
 		(Bun as unknown as CustomBunType).YAML = { parse: mockYamlParse };
-		(Bun as unknown as CustomBunType).file = mock(() => ({ text: mockFileText }));
+		(Bun as unknown as CustomBunType).file = mock(() => ({
+			text: mockFileText,
+			exists: () => Promise.resolve(true),
+		}));
 	};
 
 	it("should handle core functionality - parsing, validation, and basic operations", async () => {
@@ -329,8 +331,8 @@ describe("EntityCompose", () => {
 			return defaultYaml;
 		});
 
-		// Set up Bun mock for static method testing
-		(Bun as unknown as CustomBunType).YAML = { parse: mockYamlParse };
+		const mockFileText = mock(() => Promise.resolve(""));
+		setupBunMocks(mockYamlParse, mockFileText);
 
 		const yamlInput = `
 version: "3.9"
@@ -378,6 +380,28 @@ volumes:
 	it("should handle depends_on in object format (long syntax)", async () => {
 		await setupMocks();
 
+		const yamlInput = `
+version: "3.8"
+services:
+  app:
+    image: node:18
+    ports:
+      - "3000:3000"
+    depends_on:
+      postgres:
+        condition: service_healthy
+      redis:
+        condition: service_started
+  postgres:
+    image: postgres:13
+    ports:
+      - "5432:5432"
+  redis:
+    image: redis:alpine
+    ports:
+      - "6379:6379"
+`;
+
 		const mockYamlParse = mock((input: string) => {
 			if (input.includes("service_healthy")) {
 				return {
@@ -411,35 +435,12 @@ volumes:
 			return defaultYaml;
 		});
 
-		const mockFileText = mock(() => Promise.resolve("mock yaml content"));
+		const mockFileText = mock(() => Promise.resolve(yamlInput));
 		setupBunMocks(mockYamlParse, mockFileText);
 
 		const { EntityCompose } = await import("./compose");
 		const entityCompose = new EntityCompose("docker-compose.yml");
 
-		// Test parsing with object format depends_on
-		const yamlInput = `
-version: "3.8"
-services:
-  app:
-    image: node:18
-    ports:
-      - "3000:3000"
-    depends_on:
-      postgres:
-        condition: service_healthy
-      redis:
-        condition: service_started
-  postgres:
-    image: postgres:13
-    ports:
-      - "5432:5432"
-  redis:
-    image: redis:alpine
-    ports:
-      - "6379:6379"
-`;
-
 		const composeData = EntityCompose.parseDockerCompose(yamlInput);
 		expect(composeData.services.app.depends_on).toEqual(["postgres", "redis"]);
 

package/src/compose/compose.ts

@@ -1,5 +1,5 @@
 import { EntityAffected } from "../affected";
-import { EntityPackage } from "../package";
+import { EntityPackage, stripWorkspaceScope } from "../package";
 import type {
 	ComposeData,
 	ComposeValidationResult,
@@ -158,9 +158,7 @@ export class EntityCompose {
 
 			// Find services associated with affected packages
 			for (const service of services) {
-				const associatedPackage = allPackages.find(
-					(p) => p.replace(/^@repo\//, "") === service.name,
-				);
+				const associatedPackage = allPackages.find((p) => stripWorkspaceScope(p) === service.name);
 
 				if (keys.some((k: string) => k === associatedPackage)) {
 					affectedServices.add(service.name);

package/src/intershell-config/intershell-config.default.ts

@@ -151,7 +151,7 @@ export const defaultConfig = {
 		},
 		staged: [
 			{
-				filePattern: [/coverage\/.*/, /dist\/.*/, /node_modules\/.*/, /\.env/, /\.act/],
+				filePattern: [/coverage\/.*/, /dist\/.*/, /node_modules\/.*/, /(^|\/)\.env$/, /\.act/],
 				description: "development files should not be manually committed",
 			},
 			{

package/src/intershell-config/intershell-config.ts

@@ -1,5 +1,9 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import {
+	discoverWorkspacePackageNamesSync,
+	findWorkspaceRootSync,
+} from "../package/workspace-discovery";
 import { defaultConfig } from "./intershell-config.default";
 import type { CustomConfigJson, IConfig } from "./intershell-config.types";
 
@@ -96,29 +100,10 @@ class Config {
 		const packages: string[] = ["root"];
 
 		try {
-			// Get workspace root
-			const workspaceRoot = process.cwd();
-
-			// Check for apps directory
-			const appsPath = join(workspaceRoot, "apps");
-			if (existsSync(appsPath)) {
-				const apps = readdirSync(appsPath, { withFileTypes: true })
-					.filter((dirent) => dirent.isDirectory())
-					.map((dirent) => dirent.name);
-				packages.push(...apps);
-			}
-
-			// Check for packages directory
-			const packagesPath = join(workspaceRoot, "packages");
-			if (existsSync(packagesPath)) {
-				const pkgs = readdirSync(packagesPath, { withFileTypes: true })
-					.filter((dirent) => dirent.isDirectory())
-					.map((dirent) => `@repo/${dirent.name}`);
-				packages.push(...pkgs);
-			}
+			const workspaceRoot = findWorkspaceRootSync();
+			packages.push(...discoverWorkspacePackageNamesSync(workspaceRoot));
 		} catch {
-			// If we can't read directories, just return basic packages
-			packages.push("admin", "api", "storefront", "ui", "utils");
+			// If we can't read workspaces, fall back to root only
 		}
 
 		return packages;

package/src/package/index.ts

@@ -1,3 +1,4 @@
 export * from "./package";
 export * from "./package.shell";
 export * from "./package.types";
+export * from "./workspace-discovery";

package/src/package/package-test-mock.ts

@@ -0,0 +1,33 @@
+import { mock } from "bun:test";
+import { packagesShell } from "./package.shell";
+import type { PackageJson } from "./package.types";
+
+const defaultRootPackageJson = (): PackageJson => ({
+	name: "root",
+	version: "1.0.0",
+	private: false,
+});
+
+const defaultAppsApiPackageJson = (): PackageJson => ({
+	name: "@apps/api",
+	version: "0.1.0",
+	private: false,
+});
+
+export function installPackagesShellTestMock(): () => void {
+	const originalReadJsonFile = packagesShell.readJsonFile;
+
+	packagesShell.readJsonFile = mock((filePath: string) => {
+		if (filePath === "./package.json") {
+			return defaultRootPackageJson();
+		}
+		if (filePath === "apps/api/package.json") {
+			return defaultAppsApiPackageJson();
+		}
+		throw new Error(`Unexpected package.json path: ${filePath}`);
+	});
+
+	return () => {
+		packagesShell.readJsonFile = originalReadJsonFile;
+	};
+}

package/src/package/package.test.ts

@@ -226,13 +226,23 @@ describe("EntityPackage", () => {
 			expect(rootPackages.getPath()).toBe(".");
 		});
 
-		it("should return packages path for @repo packages", () => {
-			const repoPackages = new EntityPackage("@repo/test-package");
-			expect(repoPackages.getPath()).toBe("packages/test-package");
+		it("should return packages path for @packages packages", () => {
+			const packagesPackage = new EntityPackage("@packages/test-package");
+			expect(packagesPackage.getPath()).toBe("packages/test-package");
 		});
 
-		it("should return apps path for regular packages", () => {
-			expect(packages.getPath()).toBe("apps/test-package");
+		it("should return apps path for @apps packages", () => {
+			const appsPackage = new EntityPackage("@apps/test-app");
+			expect(appsPackage.getPath()).toBe("apps/test-app");
+		});
+
+		it("should return tools path for @tools packages", () => {
+			const toolsPackage = new EntityPackage("@tools/test-preset");
+			expect(toolsPackage.getPath()).toBe("tools/test-preset");
+		});
+
+		it("should return package name as path for unscoped packages", () => {
+			expect(packages.getPath()).toBe("test-package");
 		});
 	});
 
@@ -242,7 +252,7 @@ describe("EntityPackage", () => {
 		});
 
 		it("should return correct package.json path", () => {
-			expect(packages.getJsonPath()).toBe("apps/test-package/package.json");
+			expect(packages.getJsonPath()).toBe("test-package/package.json");
 		});
 
 		it("should return correct path for root package", () => {
@@ -250,9 +260,9 @@ describe("EntityPackage", () => {
 			expect(rootPackages.getJsonPath()).toBe("./package.json");
 		});
 
-		it("should return correct path for @repo package", () => {
-			const repoPackages = new EntityPackage("@repo/test-package");
-			expect(repoPackages.getJsonPath()).toBe("packages/test-package/package.json");
+		it("should return correct path for @packages package", () => {
+			const packagesPackage = new EntityPackage("@packages/test-package");
+			expect(packagesPackage.getJsonPath()).toBe("packages/test-package/package.json");
 		});
 	});
 
@@ -358,7 +368,7 @@ describe("EntityPackage", () => {
 		});
 
 		it("should return correct changelog path", () => {
-			expect(packages.getChangelogPath()).toBe("apps/test-package/CHANGELOG.md");
+			expect(packages.getChangelogPath()).toBe("test-package/CHANGELOG.md");
 		});
 	});
 
@@ -540,14 +550,13 @@ describe("EntityPackage", () => {
 				expect(rootPackages.getTagSeriesName()).toBe("v");
 			});
 
-			it.skip("should return 'package-name-v' for @repo packages", () => {
-				// Mock packagesShell to return @repo package for this test
+			it.skip("should return 'packages/package-name-v' for @packages packages", () => {
 				mockPackagesShell.readJsonFile.mockImplementationOnce(() =>
-					mockPackageJson({ name: "@repo/package-name", private: false }),
+					mockPackageJson({ name: "@packages/package-name", private: false }),
 				);
 
-				const intershellPackages = new EntityPackage("@repo/package-name");
-				expect(intershellPackages.getTagSeriesName()).toBe("package-name-v");
+				const intershellPackages = new EntityPackage("@packages/package-name");
+				expect(intershellPackages.getTagSeriesName()).toBe("packages/package-name-v");
 			});
 
 			it.skip("should return 'package-name-v' for regular packages", () => {
@@ -675,51 +684,79 @@ describe("EntityPackage", () => {
 
 		describe("getAllPackages", () => {
 			it("should return list of packages including root", async () => {
-				// Mock packagesShell methods for this test
 				mockPackagesShell.getWorkspaceRoot.mockResolvedValueOnce("/workspace");
-				mockPackagesShell.readDirectory
-					.mockResolvedValueOnce(["test-app", "another-app"]) // apps
-					.mockResolvedValueOnce(["ui", "utils"]); // packages
-				mockPackagesShell.canAccessFile
-					.mockResolvedValueOnce(true) // apps/test-app/package.json
-					.mockResolvedValueOnce(true) // apps/another-app/package.json
-					.mockResolvedValueOnce(true) // packages/ui/package.json
-					.mockResolvedValueOnce(true); // packages/utils/package.json
-				mockPackagesShell.readFileAsText
-					.mockResolvedValueOnce('{"name": "test-app", "version": "1.0.0"}')
-					.mockResolvedValueOnce('{"name": "another-app", "version": "1.0.0"}')
-					.mockResolvedValueOnce('{"name": "@repo/ui", "version": "1.0.0"}')
-					.mockResolvedValueOnce('{"name": "@repo/utils", "version": "1.0.0"}');
+				mockPackagesShell.readJsonFile.mockImplementation((filePath: string) => {
+					if (filePath === "/workspace/package.json") {
+						return {
+							name: "root",
+							workspaces: ["apps/*", "packages/*", "tools/*"],
+						};
+					}
+					return mockPackageJson();
+				});
+				mockPackagesShell.readDirectory.mockImplementation((dirPath: string) => {
+					if (dirPath.endsWith("/apps")) return Promise.resolve(["test-app", "another-app"]);
+					if (dirPath.endsWith("/packages")) return Promise.resolve(["ui", "utils"]);
+					if (dirPath.endsWith("/tools")) return Promise.resolve(["typescript-config"]);
+					return Promise.resolve([]);
+				});
+				mockPackagesShell.canAccessFile.mockResolvedValue(true);
+				mockPackagesShell.readFileAsText.mockImplementation((filePath: string) => {
+					const packageNames: Record<string, string> = {
+						"/workspace/apps/test-app/package.json":
+							'{"name": "@apps/test-app", "version": "1.0.0"}',
+						"/workspace/apps/another-app/package.json":
+							'{"name": "@apps/another-app", "version": "1.0.0"}',
+						"/workspace/packages/ui/package.json": '{"name": "@packages/ui", "version": "1.0.0"}',
+						"/workspace/packages/utils/package.json":
+							'{"name": "@packages/utils", "version": "1.0.0"}',
+						"/workspace/tools/typescript-config/package.json":
+							'{"name": "@tools/typescript-config", "private": true}',
+					};
+					return Promise.resolve(packageNames[filePath] ?? "");
+				});
 
 				const result = await EntityPackage.getAllPackages();
 
 				expect(result).toContain("root");
-				expect(result).toContain("test-app");
-				expect(result).toContain("another-app");
-				expect(result).toContain("@repo/ui");
-				expect(result).toContain("@repo/utils");
+				expect(result).toContain("@apps/test-app");
+				expect(result).toContain("@apps/another-app");
+				expect(result).toContain("@packages/ui");
+				expect(result).toContain("@packages/utils");
+				expect(result).toContain("@tools/typescript-config");
 			});
 
-			it("should handle empty directories gracefully", async () => {
-				// Mock packagesShell methods for this test
+			it("should handle missing workspaces field gracefully", async () => {
 				mockPackagesShell.getWorkspaceRoot.mockResolvedValueOnce("/workspace");
-				mockPackagesShell.readDirectory
-					.mockResolvedValueOnce([]) // apps
-					.mockResolvedValueOnce([]); // packages
+				mockPackagesShell.readJsonFile.mockImplementation((filePath: string) => {
+					if (filePath === "/workspace/package.json") {
+						return { name: "root" };
+					}
+					return mockPackageJson();
+				});
 
 				const result = await EntityPackage.getAllPackages();
 				expect(result).toEqual(["root"]);
 			});
 
 			it("should filter out packages without valid package.json", async () => {
-				// Mock packagesShell methods for this test
 				mockPackagesShell.getWorkspaceRoot.mockResolvedValueOnce("/workspace");
-				mockPackagesShell.readDirectory
-					.mockResolvedValueOnce(["invalid-app"]) // apps
-					.mockResolvedValueOnce(["invalid-pkg"]); // packages
-				mockPackagesShell.canAccessFile
-					.mockResolvedValueOnce(false) // apps/invalid-app/package.json
-					.mockResolvedValueOnce(false); // packages/invalid-pkg/package.json
+				mockPackagesShell.readJsonFile.mockImplementation((filePath: string) => {
+					if (filePath === "/workspace/package.json") {
+						return {
+							name: "root",
+							workspaces: ["apps/*", "packages/*", "tools/*"],
+						};
+					}
+					return mockPackageJson();
+				});
+				mockPackagesShell.readDirectory.mockImplementation((dirPath: string) => {
+					if (dirPath.endsWith("/apps")) return Promise.resolve(["invalid-app"]);
+					if (dirPath.endsWith("/packages")) return Promise.resolve(["invalid-pkg"]);
+					if (dirPath.endsWith("/tools")) return Promise.resolve(["invalid-tool"]);
+					return Promise.resolve([]);
+				});
+				mockPackagesShell.canAccessFile.mockResolvedValue(false);
 
 				const result = await EntityPackage.getAllPackages();
 				expect(result).toEqual(["root"]);
@@ -730,23 +767,23 @@ describe("EntityPackage", () => {
 	describe("edge cases and error handling", () => {
 		it("should handle package names with special characters", () => {
 			const specialPackages = new EntityPackage("test-package@1.0.0");
-			expect(specialPackages.getPath()).toBe("apps/test-package@1.0.0");
+			expect(specialPackages.getPath()).toBe("test-package@1.0.0");
 		});
 
 		it("should handle empty package name", () => {
 			const emptyPackages = new EntityPackage("");
-			expect(emptyPackages.getPath()).toBe("apps/");
+			expect(emptyPackages.getPath()).toBe("");
 		});
 
 		it("should handle very long package names", () => {
 			const longName = "a".repeat(1000);
 			const longPackages = new EntityPackage(longName);
-			expect(longPackages.getPath()).toBe(`apps/${longName}`);
+			expect(longPackages.getPath()).toBe(longName);
 		});
 
 		it("should handle package names with spaces", () => {
 			const spacedPackages = new EntityPackage("test package");
-			expect(spacedPackages.getPath()).toBe("apps/test package");
+			expect(spacedPackages.getPath()).toBe("test package");
 		});
 	});
 
@@ -762,12 +799,12 @@ describe("EntityPackage", () => {
 				.mockResolvedValueOnce(true); // packages/ui/package.json
 			mockPackagesShell.readFileAsText
 				.mockResolvedValueOnce('{"name": "test-app", "version": "1.0.0", "private": false}')
-				.mockResolvedValueOnce('{"name": "@repo/ui", "version": "1.0.0", "private": false}');
+				.mockResolvedValueOnce('{"name": "@packages/ui", "version": "1.0.0", "private": false}');
 
 			const result = await EntityPackage.getVersionedPackages();
 			expect(Array.isArray(result)).toBe(true);
 			expect(result).toContain("test-app");
-			expect(result).toContain("@repo/ui");
+			expect(result).toContain("@packages/ui");
 		});
 	});
 
@@ -779,7 +816,7 @@ describe("EntityPackage", () => {
 					return { name: "test-app", version: "1.0.0", private: true };
 				}
 				if (path.includes("ui")) {
-					return { name: "@repo/ui", version: "1.0.0", private: true };
+					return { name: "@packages/ui", version: "1.0.0", private: true };
 				}
 				// Default fallback
 				return mockPackageJson();
@@ -795,12 +832,12 @@ describe("EntityPackage", () => {
 				.mockResolvedValueOnce(true); // packages/ui/package.json
 			mockPackagesShell.readFileAsText
 				.mockResolvedValueOnce('{"name": "test-app", "version": "1.0.0", "private": true}')
-				.mockResolvedValueOnce('{"name": "@repo/ui", "version": "1.0.0", "private": true}');
+				.mockResolvedValueOnce('{"name": "@packages/ui", "version": "1.0.0", "private": true}');
 
 			const result = await EntityPackage.getUnversionedPackages();
 			expect(Array.isArray(result)).toBe(true);
 			expect(result).toContain("test-app");
-			expect(result).toContain("@repo/ui");
+			expect(result).toContain("@packages/ui");
 		});
 	});
 
@@ -816,7 +853,7 @@ describe("EntityPackage", () => {
 				.mockResolvedValueOnce(true); // packages/ui/package.json
 			mockPackagesShell.readFileAsText
 				.mockResolvedValueOnce('{"name": "test-app", "version": "1.0.0", "private": false}')
-				.mockResolvedValueOnce('{"name": "@repo/ui", "version": "1.0.0", "private": false}');
+				.mockResolvedValueOnce('{"name": "@packages/ui", "version": "1.0.0", "private": false}');
 
 			const result = await EntityPackage.validateAllPackages();
 			expect(Array.isArray(result)).toBe(true);
@@ -824,7 +861,7 @@ describe("EntityPackage", () => {
 			expect(result).toHaveLength(3);
 			expect(result).toContain("root: Consider adding a description to package.json");
 			expect(result).toContain("test-app: Consider adding a description to package.json");
-			expect(result).toContain("@repo/ui: Consider adding a description to package.json");
+			expect(result).toContain("@packages/ui: Consider adding a description to package.json");
 		});
 	});
 });

package/src/package/package.ts

@@ -2,6 +2,12 @@ import { entitiesShell } from "../entities.shell";
 import { entitiesConfig } from "../intershell-config/intershell-config";
 import { packagesShell } from "./package.shell";
 import type { PackageJson, TsConfig } from "./package.types";
+import {
+	discoverWorkspacePackageNamesAsync,
+	discoverWorkspacePackagesSync,
+	findWorkspaceRootSync,
+	getWorkspacePackagePath,
+} from "./workspace-discovery";
 
 export class EntityPackage {
 	private readonly packageName: string;
@@ -20,9 +26,16 @@ export class EntityPackage {
 
 	getPath(): string {
 		if (this.packageName === "root") return ".";
-		if (this.packageName.startsWith("@repo/"))
-			return `packages/${this.packageName.replace("@repo/", "")}`;
-		return `apps/${this.packageName}`;
+		const workspacePath = getWorkspacePackagePath(this.packageName);
+		if (workspacePath !== null) return workspacePath;
+
+		const workspaceRoot = findWorkspaceRootSync();
+		const entry = discoverWorkspacePackagesSync(workspaceRoot).find(
+			(pkg) => pkg.name === this.packageName,
+		);
+		if (entry) return entry.relativePath;
+
+		return this.packageName;
 	}
 
 	getJsonPath(): string {
@@ -138,14 +151,13 @@ export class EntityPackage {
 
 	/**
 	 * Gets the tag series name for this package
-	 * @returns tag series prefix (e.g., 'v', 'intershell-v') or null if package shouldn't be versioned
+	 * @returns tag series prefix (e.g., 'v', 'packages/intershell-v') or null if package shouldn't be versioned
 	 */
 	getTagSeriesName(): string | null {
 		if (!this.shouldVersion()) return null;
 
-		// Generate tag series name based on package name
 		if (this.packageName === "root") return "v";
-		return `${this.packageName.replace("@repo/", "")}-v`;
+		return `${this.packageName.replaceAll("@", "")}-v`;
 	}
 
 	static getRepoUrl(): string {
@@ -156,58 +168,18 @@ export class EntityPackage {
 	}
 	static async getAllPackages(): Promise<string[]> {
 		const packages: string[] = ["root"];
-
-		// Get workspace root
 		const workspaceRoot = await packagesShell.getWorkspaceRoot();
-
-		// Read apps directory
-		let apps: string[] = [];
-		try {
-			const appsPath = `${workspaceRoot}/apps`;
-			apps = await packagesShell.readDirectory(appsPath);
-		} catch {
-			// apps directory doesn't exist or can't be read
-		}
-
-		// Read packages directory
-		let pkgs: string[] = [];
-		try {
-			const packagesPath = `${workspaceRoot}/packages`;
-			const packageNames = await packagesShell.readDirectory(packagesPath);
-			pkgs = packageNames.map((name) => `@repo/${name}`);
-		} catch {
-			// packages directory doesn't exist or can't be read
-		}
-
-		// Filter packages that have valid package.json files
-		const filteredPackages = await Promise.all(
-			[...apps, ...pkgs].map(async (pkg) => {
-				const packageInstance = new EntityPackage(pkg);
-				const packageJsonPath = packageInstance.getJsonPath();
-
-				try {
-					const exists = await packagesShell.canAccessFile(packageJsonPath);
-					if (!exists) return null;
-
-					const packageJsonContent = await packagesShell.readFileAsText(packageJsonPath);
-					const packageJson = JSON.parse(packageJsonContent);
-					const name = packageJson.name;
-
-					if (!name) return null;
-
-					if (name !== pkg) {
-						throw new Error(`Package ${pkg} has a different name in package.json: ${name}`);
-					}
-
-					return name;
-				} catch {
-					return null;
-				}
-			}),
+		const rootPackageJson = packagesShell.readJsonFile(`${workspaceRoot}/package.json`);
+
+		const workspacePackages = await discoverWorkspacePackageNamesAsync(
+			workspaceRoot,
+			packagesShell.readDirectory,
+			packagesShell.canAccessFile,
+			packagesShell.readFileAsText,
+			rootPackageJson,
 		);
 
-		packages.push(...filteredPackages.filter((pkg): pkg is string => pkg !== null));
-
+		packages.push(...workspacePackages);
 		return packages;
 	}
 

package/src/package/package.types.ts

@@ -17,7 +17,7 @@ export interface PackageJson {
 	homepage?: string;
 	keywords?: string[];
 	private?: boolean;
-	workspaces?: string[];
+	workspaces?: string[] | { packages?: string[] };
 	[key: string]: unknown;
 }