intershell 0.6.1 → 0.6.3

package/src/package/workspace-discovery.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, test } from "bun:test";
+import {
+	packageNameFromAbsolutePath,
+	parseWorkspacePatterns,
+	type WorkspacePackageEntry,
+} from "./workspace-discovery";
+
+describe("workspace-discovery", () => {
+	test("parseWorkspacePatterns handles array format", () => {
+		expect(parseWorkspacePatterns(["apps/*", "packages/*"])).toEqual(["apps/*", "packages/*"]);
+	});
+
+	test("parseWorkspacePatterns handles object format", () => {
+		expect(parseWorkspacePatterns({ packages: ["tools/*"] })).toEqual(["tools/*"]);
+	});
+
+	test("parseWorkspacePatterns returns empty for missing workspaces", () => {
+		expect(parseWorkspacePatterns(undefined)).toEqual([]);
+	});
+
+	test("packageNameFromAbsolutePath resolves workspace package from path", () => {
+		const workspacePackages: WorkspacePackageEntry[] = [
+			{ relativePath: "packages/ui", name: "@packages/ui" },
+			{ relativePath: "apps/api", name: "@apps/api" },
+		];
+
+		expect(
+			packageNameFromAbsolutePath(
+				"/workspace/packages/ui/src/index.ts",
+				"/workspace",
+				workspacePackages,
+			),
+		).toBe("@packages/ui");
+
+		expect(
+			packageNameFromAbsolutePath(
+				"/workspace/apps/api/Dockerfile",
+				"/workspace",
+				workspacePackages,
+			),
+		).toBe("@apps/api");
+	});
+
+	test("packageNameFromAbsolutePath returns null for paths outside workspace", () => {
+		expect(
+			packageNameFromAbsolutePath("/other/path", "/workspace", [
+				{ relativePath: "packages/ui", name: "@packages/ui" },
+			]),
+		).toBeNull();
+	});
+});

package/src/package/workspace-discovery.ts

@@ -0,0 +1,219 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { PackageJson } from "./package.types";
+
+export interface WorkspacePackageEntry {
+	readonly relativePath: string;
+	readonly name: string;
+}
+
+/** Scoped workspace package: `@scope/name` → filesystem path `scope/name` */
+export function getWorkspacePackagePath(packageName: string): string | null {
+	if (!packageName.startsWith("@") || !packageName.includes("/")) return null;
+	return packageName.slice(1);
+}
+
+/** Last path segment of a scoped package (e.g. `@packages/ui` → `ui`) for service name matching */
+export function stripWorkspaceScope(packageName: string): string {
+	const workspacePath = getWorkspacePackagePath(packageName);
+	if (workspacePath === null) return packageName;
+	const slashIndex = workspacePath.lastIndexOf("/");
+	return slashIndex === -1 ? workspacePath : workspacePath.slice(slashIndex + 1);
+}
+
+export function parseWorkspacePatterns(workspaces: PackageJson["workspaces"]): string[] {
+	if (!workspaces) return [];
+	if (Array.isArray(workspaces)) return workspaces;
+	return workspaces.packages ?? [];
+}
+
+export function findWorkspaceRootSync(startDir: string = process.cwd()): string {
+	let workspaceRoot = startDir;
+	while (workspaceRoot !== dirname(workspaceRoot)) {
+		if (existsSync(join(workspaceRoot, "package.json"))) return workspaceRoot;
+		workspaceRoot = dirname(workspaceRoot);
+	}
+	return startDir;
+}
+
+export function expandWorkspacePatterns(workspaceRoot: string, patterns: string[]): string[] {
+	const paths = new Set<string>();
+	for (const pattern of patterns) {
+		for (const path of expandWorkspacePattern(workspaceRoot, pattern)) {
+			paths.add(path);
+		}
+	}
+	return [...paths];
+}
+
+function expandWorkspacePattern(workspaceRoot: string, pattern: string): string[] {
+	const normalized = pattern.replace(/\\/g, "/");
+	if (!normalized.includes("*")) return [normalized];
+
+	const parts = normalized.split("/");
+	const starIndex = parts.findIndex((part) => part === "*");
+	if (starIndex === -1) return [normalized];
+
+	const baseParts = parts.slice(0, starIndex);
+	const suffixParts = parts.slice(starIndex + 1);
+	const baseDir = join(workspaceRoot, ...baseParts);
+	if (!existsSync(baseDir)) return [];
+
+	return readdirSync(baseDir, { withFileTypes: true })
+		.filter((entry) => entry.isDirectory())
+		.flatMap((entry) => {
+			const childPattern = [...baseParts, entry.name, ...suffixParts].join("/");
+			return expandWorkspacePattern(workspaceRoot, childPattern);
+		});
+}
+
+export function discoverWorkspacePackagesSync(workspaceRoot: string): WorkspacePackageEntry[] {
+	const rootPackageJsonPath = join(workspaceRoot, "package.json");
+	if (!existsSync(rootPackageJsonPath)) return [];
+
+	const rootPackageJson = JSON.parse(readFileSync(rootPackageJsonPath, "utf-8")) as PackageJson;
+	const patterns = parseWorkspacePatterns(rootPackageJson.workspaces);
+	if (patterns.length === 0) return [];
+
+	const entries: WorkspacePackageEntry[] = [];
+	for (const relativePath of expandWorkspacePatterns(workspaceRoot, patterns)) {
+		const packageJsonPath = join(workspaceRoot, relativePath, "package.json");
+		if (!existsSync(packageJsonPath)) continue;
+
+		try {
+			const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8")) as PackageJson;
+			if (packageJson.name) {
+				entries.push({ relativePath, name: packageJson.name });
+			}
+		} catch {
+			// skip invalid package.json
+		}
+	}
+
+	return entries;
+}
+
+export function discoverWorkspacePackageNamesSync(workspaceRoot: string): string[] {
+	return discoverWorkspacePackagesSync(workspaceRoot).map((entry) => entry.name);
+}
+
+export function packageNameFromAbsolutePath(
+	absolutePath: string,
+	workspaceRoot: string,
+	workspacePackages: readonly WorkspacePackageEntry[],
+): string | null {
+	const normalizedPath = absolutePath.replace(/\\/g, "/");
+	const normalizedRoot = workspaceRoot.replace(/\\/g, "/").replace(/\/$/, "");
+
+	if (!normalizedPath.startsWith(normalizedRoot)) return null;
+
+	const relativePath = normalizedPath.slice(normalizedRoot.length).replace(/^\//, "");
+	const sortedEntries = [...workspacePackages].sort(
+		(a, b) => b.relativePath.length - a.relativePath.length,
+	);
+
+	for (const entry of sortedEntries) {
+		if (relativePath === entry.relativePath || relativePath.startsWith(`${entry.relativePath}/`)) {
+			return entry.name;
+		}
+	}
+
+	return null;
+}
+
+export async function discoverWorkspacePackagesAsync(
+	workspaceRoot: string,
+	readDirectory: (dirPath: string) => Promise<string[]>,
+	canAccessFile: (filePath: string) => Promise<boolean>,
+	readFileAsText: (filePath: string) => Promise<string>,
+	rootPackageJson: PackageJson,
+): Promise<WorkspacePackageEntry[]> {
+	const patterns = parseWorkspacePatterns(rootPackageJson.workspaces);
+	if (patterns.length === 0) return [];
+
+	const entries: WorkspacePackageEntry[] = [];
+	for (const relativePath of await expandWorkspacePatternsAsync(
+		workspaceRoot,
+		patterns,
+		readDirectory,
+	)) {
+		const packageJsonPath = join(workspaceRoot, relativePath, "package.json");
+		try {
+			const exists = await canAccessFile(packageJsonPath);
+			if (!exists) continue;
+
+			const content = await readFileAsText(packageJsonPath);
+			const packageJson = JSON.parse(content) as PackageJson;
+			if (packageJson.name) {
+				entries.push({ relativePath, name: packageJson.name });
+			}
+		} catch {
+			// skip invalid package.json
+		}
+	}
+
+	return entries;
+}
+
+export async function discoverWorkspacePackageNamesAsync(
+	workspaceRoot: string,
+	readDirectory: (dirPath: string) => Promise<string[]>,
+	canAccessFile: (filePath: string) => Promise<boolean>,
+	readFileAsText: (filePath: string) => Promise<string>,
+	rootPackageJson: PackageJson,
+): Promise<string[]> {
+	const entries = await discoverWorkspacePackagesAsync(
+		workspaceRoot,
+		readDirectory,
+		canAccessFile,
+		readFileAsText,
+		rootPackageJson,
+	);
+	return entries.map((entry) => entry.name);
+}
+
+async function expandWorkspacePatternsAsync(
+	workspaceRoot: string,
+	patterns: string[],
+	readDirectory: (dirPath: string) => Promise<string[]>,
+): Promise<string[]> {
+	const paths = new Set<string>();
+	for (const pattern of patterns) {
+		for (const path of await expandWorkspacePatternAsync(workspaceRoot, pattern, readDirectory)) {
+			paths.add(path);
+		}
+	}
+	return [...paths];
+}
+
+async function expandWorkspacePatternAsync(
+	workspaceRoot: string,
+	pattern: string,
+	readDirectory: (dirPath: string) => Promise<string[]>,
+): Promise<string[]> {
+	const normalized = pattern.replace(/\\/g, "/");
+	if (!normalized.includes("*")) return [normalized];
+
+	const parts = normalized.split("/");
+	const starIndex = parts.findIndex((part) => part === "*");
+	if (starIndex === -1) return [normalized];
+
+	const baseParts = parts.slice(0, starIndex);
+	const suffixParts = parts.slice(starIndex + 1);
+	const baseDir = join(workspaceRoot, ...baseParts);
+
+	let entries: string[] = [];
+	try {
+		entries = await readDirectory(baseDir);
+	} catch {
+		return [];
+	}
+
+	const results: string[] = [];
+	for (const entry of entries) {
+		const childPattern = [...baseParts, entry, ...suffixParts].join("/");
+		const expanded = await expandWorkspacePatternAsync(workspaceRoot, childPattern, readDirectory);
+		results.push(...expanded);
+	}
+	return results;
+}

package/src/package-commits/dependency-analyzer.ts

@@ -1,7 +1,15 @@
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { entitiesShell } from "../entities.shell";
-import { EntityPackage, type TsConfig, type TsConfigPaths } from "../package";
+import {
+	discoverWorkspacePackagesAsync,
+	EntityPackage,
+	packageNameFromAbsolutePath,
+	type TsConfig,
+	type TsConfigPaths,
+	type WorkspacePackageEntry,
+} from "../package";
+import { packagesShell } from "../package/package.shell";
 
 export class EntityDependencyAnalyzer {
 	private readonly package: EntityPackage;
@@ -16,28 +24,48 @@ export class EntityDependencyAnalyzer {
 	 */
 	async getPackageDependenciesAtRef(reference: string): Promise<string[]> {
 		try {
-			// Get all internal packages in the monorepo
 			const allPackages = await EntityPackage.getAllPackages();
+			const internalPackages = new Set(allPackages);
+			const workspaceContext = await this.getWorkspaceContext();
 
-			// Get package.json dependencies
-			const packageJsonDeps = await this.getPackageJsonDependencies(reference);
-
-			// Get tsconfig dependencies
-			const tsconfigDeps = await this.getTsConfigDependencies(reference);
+			const packageJsonDeps = await this.getPackageJsonDependencies(reference, internalPackages);
+			const tsconfigDeps = await this.getTsConfigDependencies(
+				reference,
+				internalPackages,
+				workspaceContext,
+			);
 
-			// Combine and filter for internal dependencies only
 			const allDeps = [...new Set([...packageJsonDeps, ...tsconfigDeps])];
-
-			return allDeps.filter((dep) => allPackages.includes(dep));
+			return allDeps.filter((dep) => internalPackages.has(dep));
 		} catch {
 			return [];
 		}
 	}
 
+	private async getWorkspaceContext(): Promise<{
+		readonly workspaceRoot: string;
+		readonly workspacePackages: WorkspacePackageEntry[];
+	}> {
+		const workspaceRoot = await packagesShell.getWorkspaceRoot();
+		const rootPackageJson = packagesShell.readJsonFile(`${workspaceRoot}/package.json`);
+		const workspacePackages = await discoverWorkspacePackagesAsync(
+			workspaceRoot,
+			packagesShell.readDirectory,
+			packagesShell.canAccessFile,
+			packagesShell.readFileAsText,
+			rootPackageJson,
+		);
+
+		return { workspaceRoot, workspacePackages };
+	}
+
 	/**
 	 * Get package.json dependencies for a package at a specific reference
 	 */
-	private async getPackageJsonDependencies(reference: string): Promise<string[]> {
+	private async getPackageJsonDependencies(
+		reference: string,
+		internalPackages: ReadonlySet<string>,
+	): Promise<string[]> {
 		try {
 			const result = await entitiesShell.gitShowPackageJsonAtTag(
 				reference,
@@ -61,8 +89,7 @@ export class EntityDependencyAnalyzer {
 					: []),
 			];
 
-			// Filter for @repo/ packages and return without @repo/ prefix
-			return deps.filter((dep) => dep.startsWith("@repo/")).map((dep) => dep.replace("@repo/", ""));
+			return deps.filter((dep) => internalPackages.has(dep));
 		} catch {
 			return [];
 		}
@@ -71,7 +98,14 @@ export class EntityDependencyAnalyzer {
 	/**
 	 * Get tsconfig dependencies by resolving paths to actual internal packages
 	 */
-	private async getTsConfigDependencies(reference: string): Promise<string[]> {
+	private async getTsConfigDependencies(
+		reference: string,
+		internalPackages: ReadonlySet<string>,
+		workspaceContext: {
+			readonly workspaceRoot: string;
+			readonly workspacePackages: WorkspacePackageEntry[];
+		},
+	): Promise<string[]> {
 		try {
 			const packagePath = this.package.getPath();
 			const tsconfigPaths = await this.getTsConfigPaths(reference);
@@ -79,16 +113,18 @@ export class EntityDependencyAnalyzer {
 			const deps: string[] = [];
 
 			for (const [alias, paths] of Object.entries(tsconfigPaths)) {
-				// Check if alias itself is an internal package
-				if (alias.startsWith("@repo/")) {
-					deps.push(alias.replace("@repo/", ""));
+				if (internalPackages.has(alias)) {
+					deps.push(alias);
 				}
 
-				// Check if paths point to internal packages
 				if (Array.isArray(paths)) {
 					for (const path of paths) {
 						const resolvedPath = resolve(packagePath, path);
-						const internalPackage = this.findInternalPackageFromPath(resolvedPath);
+						const internalPackage = this.findInternalPackageFromPath(
+							resolvedPath,
+							workspaceContext.workspaceRoot,
+							workspaceContext.workspacePackages,
+						);
 						if (internalPackage) {
 							deps.push(internalPackage);
 						}
@@ -102,23 +138,12 @@ export class EntityDependencyAnalyzer {
 		}
 	}
 
-	/**
-	 * Find internal package name from absolute path
-	 */
-	private findInternalPackageFromPath(absolutePath: string): string | null {
-		// Check if path points to packages/ or apps/ directory
-		const packagesMatch = absolutePath.match(/\/packages\/([^/]+)/);
-		const appsMatch = absolutePath.match(/\/apps\/([^/]+)/);
-
-		if (packagesMatch) {
-			return `@repo/${packagesMatch[1]}`;
-		}
-
-		if (appsMatch) {
-			return appsMatch[1];
-		}
-
-		return null;
+	private findInternalPackageFromPath(
+		absolutePath: string,
+		workspaceRoot: string,
+		workspacePackages: readonly WorkspacePackageEntry[],
+	): string | null {
+		return packageNameFromAbsolutePath(absolutePath, workspaceRoot, workspacePackages);
 	}
 
 	/**
@@ -142,14 +167,12 @@ export class EntityDependencyAnalyzer {
 		try {
 			const result = await entitiesShell.gitShow(`${reference}:${this.package.getTsconfigPath()}`);
 			if (result.exitCode !== 0) {
-				// If tsconfig.json doesn't exist at this reference, return empty config
 				return {};
 			}
 
 			const content = result.text();
 			return JSON.parse(content);
 		} catch {
-			// If parsing fails, return empty config
 			return {};
 		}
 	}
@@ -171,10 +194,8 @@ export class EntityDependencyAnalyzer {
 			const extendedContent = readFileSync(extendedPath, "utf-8");
 			const extendedConfig: TsConfig = JSON.parse(extendedContent);
 
-			// Recursively resolve extended configs
 			const resolvedExtended = await this.resolveExtendedTsConfig(extendedConfig, packagePath);
 
-			// Merge configurations
 			return {
 				...resolvedExtended,
 				...config,

package/src/package-commits/package-commits.test.ts

@@ -1,10 +1,21 @@
-import { describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { EntityPackage } from "../package";
+import { installPackagesShellTestMock } from "../package/package-test-mock";
 import { EntityPackageCommits } from "./package-commits";
 
 describe("EntityPackageCommits", () => {
+	let restorePackagesShellMock: () => void;
+
+	beforeEach(() => {
+		restorePackagesShellMock = installPackagesShellTestMock();
+	});
+
+	afterEach(() => {
+		restorePackagesShellMock();
+	});
+
 	test("should create instance", () => {
-		const packageInstance = new EntityPackage("api");
+		const packageInstance = new EntityPackage("@apps/api");
 		const commitPackage = new EntityPackageCommits(packageInstance);
 		expect(commitPackage).toBeDefined();
 	});
@@ -16,9 +27,8 @@ describe("EntityPackageCommits", () => {
 	});
 
 	test("should have main method", () => {
-		const packageInstance = new EntityPackage("api");
+		const packageInstance = new EntityPackage("@apps/api");
 		const commitPackage = new EntityPackageCommits(packageInstance);
-		// Check that the main method exists
 		expect(typeof commitPackage.getCommitsInRange).toBe("function");
 	});
 
@@ -26,16 +36,14 @@ describe("EntityPackageCommits", () => {
 		test("should return empty array when git operations fail", async () => {
 			const packageInstance = new EntityPackage("root");
 			const commitPackage = new EntityPackageCommits(packageInstance);
-			// Test with invalid range to trigger error handling
 			const result = await commitPackage.getCommitsInRange("invalid", "invalid");
 			expect(Array.isArray(result)).toBe(true);
 			expect(result.length).toBe(0);
 		});
 
 		test("should handle package-specific commits", async () => {
-			const packageInstance = new EntityPackage("api");
+			const packageInstance = new EntityPackage("@apps/api");
 			const commitPackage = new EntityPackageCommits(packageInstance);
-			// Test with invalid range to trigger error handling
 			const result = await commitPackage.getCommitsInRange("invalid", "invalid");
 			expect(Array.isArray(result)).toBe(true);
 			expect(result.length).toBe(0);

package/src/package-tags/package-tags.test.ts

@@ -1,10 +1,21 @@
-import { describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { EntityPackage } from "../package";
+import { installPackagesShellTestMock } from "../package/package-test-mock";
 import { EntityPackageTags } from "./package-tags";
 
 describe("EntityPackageTags", () => {
+	let restorePackagesShellMock: () => void;
+
+	beforeEach(() => {
+		restorePackagesShellMock = installPackagesShellTestMock();
+	});
+
+	afterEach(() => {
+		restorePackagesShellMock();
+	});
+
 	test("should create instance", () => {
-		const packageInstance = new EntityPackage("api");
+		const packageInstance = new EntityPackage("@apps/api");
 		const tagPackage = new EntityPackageTags(packageInstance);
 		expect(tagPackage).toBeDefined();
 	});
@@ -25,49 +36,45 @@ describe("EntityPackageTags", () => {
 	});
 
 	test("should detect tag prefix for package-specific tags", () => {
-		const packageInstance = new EntityPackage("api");
+		const packageInstance = new EntityPackage("@apps/api");
 		const tagPackage = new EntityPackageTags(packageInstance);
 
-		expect(tagPackage.detectTagPrefix("api-v1.0.0")).toBe("api-v");
-		expect(tagPackage.detectTagPrefix("intershell-v2.1.3")).toBe("intershell-v");
-		expect(tagPackage.detectTagPrefix("ui-v0.0.1")).toBe("ui-v");
+		expect(tagPackage.detectTagPrefix("apps/api-v1.0.0")).toBe("apps/api-v");
+		expect(tagPackage.detectTagPrefix("packages/intershell-v2.1.3")).toBe("packages/intershell-v");
+		expect(tagPackage.detectTagPrefix("packages/ui-v0.0.1")).toBe("packages/ui-v");
 	});
 
 	test("should return undefined for invalid tag formats", () => {
-		const packageInstance = new EntityPackage("api");
+		const packageInstance = new EntityPackage("@apps/api");
 		const tagPackage = new EntityPackageTags(packageInstance);
 
 		expect(tagPackage.detectTagPrefix("1.0.0")).toBeUndefined();
-		expect(tagPackage.detectTagPrefix("invalid")).toBeUndefined();
+		expect(tagPackage.detectTagPrefix("invalid-tag")).toBeUndefined();
 		expect(tagPackage.detectTagPrefix("")).toBeUndefined();
 	});
 
 	test("should compare versions correctly", () => {
-		const packageInstance = new EntityPackage("api");
+		const packageInstance = new EntityPackage("@apps/api");
 		const tagPackage = new EntityPackageTags(packageInstance);
 
-		expect(tagPackage.compareVersions("1.0.0", "1.0.1")).toBe(-1);
-		expect(tagPackage.compareVersions("1.0.1", "1.0.0")).toBe(1);
 		expect(tagPackage.compareVersions("1.0.0", "1.0.0")).toBe(0);
-		expect(tagPackage.compareVersions("2.0.0", "1.9.9")).toBe(1);
-		expect(tagPackage.compareVersions("1.0.0", "2.0.0")).toBe(-1);
+		expect(tagPackage.compareVersions("1.1.0", "1.0.0")).toBe(1);
+		expect(tagPackage.compareVersions("1.0.0", "1.1.0")).toBe(-1);
 	});
 
 	test("should handle version comparison with different lengths", () => {
-		const packageInstance = new EntityPackage("api");
+		const packageInstance = new EntityPackage("@apps/api");
 		const tagPackage = new EntityPackageTags(packageInstance);
 
+		expect(tagPackage.compareVersions("1.0.0.1", "1.0.0")).toBe(1);
 		expect(tagPackage.compareVersions("1.0", "1.0.0")).toBe(0);
-		expect(tagPackage.compareVersions("1.0.0", "1.0")).toBe(0);
-		expect(tagPackage.compareVersions("1", "1.0.0")).toBe(0);
 	});
 
 	test("should handle version comparison edge cases", () => {
-		const packageInstance = new EntityPackage("api");
+		const packageInstance = new EntityPackage("@apps/api");
 		const tagPackage = new EntityPackageTags(packageInstance);
 
-		expect(tagPackage.compareVersions("0.0.0", "0.0.1")).toBe(-1);
-		expect(tagPackage.compareVersions("0.1.0", "0.0.9")).toBe(1);
-		expect(tagPackage.compareVersions("1.0.0", "0.9.9")).toBe(1);
+		expect(tagPackage.compareVersions("0.0.1", "0.0.0")).toBe(1);
+		expect(tagPackage.compareVersions("10.0.0", "9.0.0")).toBe(1);
 	});
 });

package/src/package-tags/package-tags.ts

@@ -188,7 +188,7 @@ export class EntityPackageTags {
 				packageName = matchingPackage;
 			} else {
 				throw new Error(
-					`Invalid tag prefix format: "${prefix}". Expected format: v (root) or package-name-v (e.g., api-v, intershell-v)`,
+					`Invalid tag prefix format: "${prefix}". Expected format: v (root) or <scope>/<name>-v (e.g., apps/api-v, packages/intershell-v)`,
 				);
 			}