pi-usereq 0.49.0 → 0.51.0

package/pi.dev-src/pi-mono/coding-agent/test/model-resolver.test.ts

@@ -1,436 +0,0 @@
-import type { Model } from "@mariozechner/pi-ai";
-import { describe, expect, test } from "vitest";
-import {
-	defaultModelPerProvider,
-	findInitialModel,
-	parseModelPattern,
-	resolveCliModel,
-} from "../src/core/model-resolver.js";
-
-// Mock models for testing
-const mockModels: Model<"anthropic-messages">[] = [
-	{
-		id: "claude-sonnet-4-5",
-		name: "Claude Sonnet 4.5",
-		api: "anthropic-messages",
-		provider: "anthropic",
-		baseUrl: "https://api.anthropic.com",
-		reasoning: true,
-		input: ["text", "image"],
-		cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
-		contextWindow: 200000,
-		maxTokens: 8192,
-	},
-	{
-		id: "gpt-4o",
-		name: "GPT-4o",
-		api: "anthropic-messages", // Using same type for simplicity
-		provider: "openai",
-		baseUrl: "https://api.openai.com",
-		reasoning: false,
-		input: ["text", "image"],
-		cost: { input: 5, output: 15, cacheRead: 0.5, cacheWrite: 5 },
-		contextWindow: 128000,
-		maxTokens: 4096,
-	},
-];
-
-// Mock OpenRouter models with colons in IDs
-const mockOpenRouterModels: Model<"anthropic-messages">[] = [
-	{
-		id: "qwen/qwen3-coder:exacto",
-		name: "Qwen3 Coder Exacto",
-		api: "anthropic-messages",
-		provider: "openrouter",
-		baseUrl: "https://openrouter.ai/api/v1",
-		reasoning: true,
-		input: ["text"],
-		cost: { input: 1, output: 2, cacheRead: 0.1, cacheWrite: 1 },
-		contextWindow: 128000,
-		maxTokens: 8192,
-	},
-	{
-		id: "openai/gpt-4o:extended",
-		name: "GPT-4o Extended",
-		api: "anthropic-messages",
-		provider: "openrouter",
-		baseUrl: "https://openrouter.ai/api/v1",
-		reasoning: false,
-		input: ["text", "image"],
-		cost: { input: 5, output: 15, cacheRead: 0.5, cacheWrite: 5 },
-		contextWindow: 128000,
-		maxTokens: 4096,
-	},
-];
-
-const allModels = [...mockModels, ...mockOpenRouterModels];
-
-describe("parseModelPattern", () => {
-	describe("simple patterns without colons", () => {
-		test("exact match returns model with undefined thinking level", () => {
-			const result = parseModelPattern("claude-sonnet-4-5", allModels);
-			expect(result.model?.id).toBe("claude-sonnet-4-5");
-			expect(result.thinkingLevel).toBeUndefined();
-			expect(result.warning).toBeUndefined();
-		});
-
-		test("partial match returns best model with undefined thinking level", () => {
-			const result = parseModelPattern("sonnet", allModels);
-			expect(result.model?.id).toBe("claude-sonnet-4-5");
-			expect(result.thinkingLevel).toBeUndefined();
-			expect(result.warning).toBeUndefined();
-		});
-
-		test("no match returns undefined model and thinking level", () => {
-			const result = parseModelPattern("nonexistent", allModels);
-			expect(result.model).toBeUndefined();
-			expect(result.thinkingLevel).toBeUndefined();
-			expect(result.warning).toBeUndefined();
-		});
-	});
-
-	describe("patterns with valid thinking levels", () => {
-		test("sonnet:high returns sonnet with high thinking level", () => {
-			const result = parseModelPattern("sonnet:high", allModels);
-			expect(result.model?.id).toBe("claude-sonnet-4-5");
-			expect(result.thinkingLevel).toBe("high");
-			expect(result.warning).toBeUndefined();
-		});
-
-		test("gpt-4o:medium returns gpt-4o with medium thinking level", () => {
-			const result = parseModelPattern("gpt-4o:medium", allModels);
-			expect(result.model?.id).toBe("gpt-4o");
-			expect(result.thinkingLevel).toBe("medium");
-			expect(result.warning).toBeUndefined();
-		});
-
-		test("all valid thinking levels work", () => {
-			for (const level of ["off", "minimal", "low", "medium", "high", "xhigh"]) {
-				const result = parseModelPattern(`sonnet:${level}`, allModels);
-				expect(result.model?.id).toBe("claude-sonnet-4-5");
-				expect(result.thinkingLevel).toBe(level);
-				expect(result.warning).toBeUndefined();
-			}
-		});
-	});
-
-	describe("patterns with invalid thinking levels", () => {
-		test("sonnet:random returns sonnet with undefined thinking level and warning", () => {
-			const result = parseModelPattern("sonnet:random", allModels);
-			expect(result.model?.id).toBe("claude-sonnet-4-5");
-			expect(result.thinkingLevel).toBeUndefined();
-			expect(result.warning).toContain("Invalid thinking level");
-			expect(result.warning).toContain("random");
-		});
-
-		test("gpt-4o:invalid returns gpt-4o with undefined thinking level and warning", () => {
-			const result = parseModelPattern("gpt-4o:invalid", allModels);
-			expect(result.model?.id).toBe("gpt-4o");
-			expect(result.thinkingLevel).toBeUndefined();
-			expect(result.warning).toContain("Invalid thinking level");
-		});
-	});
-
-	describe("OpenRouter models with colons in IDs", () => {
-		test("qwen3-coder:exacto matches the model with undefined thinking level", () => {
-			const result = parseModelPattern("qwen/qwen3-coder:exacto", allModels);
-			expect(result.model?.id).toBe("qwen/qwen3-coder:exacto");
-			expect(result.thinkingLevel).toBeUndefined();
-			expect(result.warning).toBeUndefined();
-		});
-
-		test("openrouter/qwen/qwen3-coder:exacto matches with provider prefix", () => {
-			const result = parseModelPattern("openrouter/qwen/qwen3-coder:exacto", allModels);
-			expect(result.model?.id).toBe("qwen/qwen3-coder:exacto");
-			expect(result.model?.provider).toBe("openrouter");
-			expect(result.thinkingLevel).toBeUndefined();
-			expect(result.warning).toBeUndefined();
-		});
-
-		test("qwen3-coder:exacto:high matches model with high thinking level", () => {
-			const result = parseModelPattern("qwen/qwen3-coder:exacto:high", allModels);
-			expect(result.model?.id).toBe("qwen/qwen3-coder:exacto");
-			expect(result.thinkingLevel).toBe("high");
-			expect(result.warning).toBeUndefined();
-		});
-
-		test("openrouter/qwen/qwen3-coder:exacto:high matches with provider and thinking level", () => {
-			const result = parseModelPattern("openrouter/qwen/qwen3-coder:exacto:high", allModels);
-			expect(result.model?.id).toBe("qwen/qwen3-coder:exacto");
-			expect(result.model?.provider).toBe("openrouter");
-			expect(result.thinkingLevel).toBe("high");
-			expect(result.warning).toBeUndefined();
-		});
-
-		test("gpt-4o:extended matches the extended model with undefined thinking level", () => {
-			const result = parseModelPattern("openai/gpt-4o:extended", allModels);
-			expect(result.model?.id).toBe("openai/gpt-4o:extended");
-			expect(result.thinkingLevel).toBeUndefined();
-			expect(result.warning).toBeUndefined();
-		});
-	});
-
-	describe("invalid thinking levels with OpenRouter models", () => {
-		test("qwen3-coder:exacto:random returns model with undefined thinking level and warning", () => {
-			const result = parseModelPattern("qwen/qwen3-coder:exacto:random", allModels);
-			expect(result.model?.id).toBe("qwen/qwen3-coder:exacto");
-			expect(result.thinkingLevel).toBeUndefined();
-			expect(result.warning).toContain("Invalid thinking level");
-			expect(result.warning).toContain("random");
-		});
-
-		test("qwen3-coder:exacto:high:random returns model with undefined thinking level and warning", () => {
-			const result = parseModelPattern("qwen/qwen3-coder:exacto:high:random", allModels);
-			expect(result.model?.id).toBe("qwen/qwen3-coder:exacto");
-			expect(result.thinkingLevel).toBeUndefined();
-			expect(result.warning).toContain("Invalid thinking level");
-			expect(result.warning).toContain("random");
-		});
-	});
-
-	describe("edge cases", () => {
-		test("empty pattern matches via partial matching", () => {
-			// Empty string is included in all model IDs, so partial matching finds a match
-			const result = parseModelPattern("", allModels);
-			expect(result.model).not.toBeNull();
-			expect(result.thinkingLevel).toBeUndefined();
-		});
-
-		test("pattern ending with colon treats empty suffix as invalid", () => {
-			const result = parseModelPattern("sonnet:", allModels);
-			// Empty string after colon is not a valid thinking level
-			// So it tries to match "sonnet:" which won't match, then tries "sonnet"
-			expect(result.model?.id).toBe("claude-sonnet-4-5");
-			expect(result.warning).toContain("Invalid thinking level");
-		});
-	});
-});
-
-describe("resolveCliModel", () => {
-	test("resolves --model provider/id without --provider", () => {
-		const registry = {
-			getAll: () => allModels,
-		} as unknown as Parameters<typeof resolveCliModel>[0]["modelRegistry"];
-
-		const result = resolveCliModel({
-			cliModel: "openai/gpt-4o",
-			modelRegistry: registry,
-		});
-
-		expect(result.error).toBeUndefined();
-		expect(result.model?.provider).toBe("openai");
-		expect(result.model?.id).toBe("gpt-4o");
-	});
-
-	test("resolves fuzzy patterns within an explicit provider", () => {
-		const registry = {
-			getAll: () => allModels,
-		} as unknown as Parameters<typeof resolveCliModel>[0]["modelRegistry"];
-
-		const result = resolveCliModel({
-			cliProvider: "openai",
-			cliModel: "4o",
-			modelRegistry: registry,
-		});
-
-		expect(result.error).toBeUndefined();
-		expect(result.model?.provider).toBe("openai");
-		expect(result.model?.id).toBe("gpt-4o");
-	});
-
-	test("supports --model <pattern>:<thinking> (without explicit --thinking)", () => {
-		const registry = {
-			getAll: () => allModels,
-		} as unknown as Parameters<typeof resolveCliModel>[0]["modelRegistry"];
-
-		const result = resolveCliModel({
-			cliModel: "sonnet:high",
-			modelRegistry: registry,
-		});
-
-		expect(result.error).toBeUndefined();
-		expect(result.model?.id).toBe("claude-sonnet-4-5");
-		expect(result.thinkingLevel).toBe("high");
-	});
-
-	test("prefers exact model id match over provider inference (OpenRouter-style ids)", () => {
-		const registry = {
-			getAll: () => allModels,
-		} as unknown as Parameters<typeof resolveCliModel>[0]["modelRegistry"];
-
-		const result = resolveCliModel({
-			cliModel: "openai/gpt-4o:extended",
-			modelRegistry: registry,
-		});
-
-		expect(result.error).toBeUndefined();
-		expect(result.model?.provider).toBe("openrouter");
-		expect(result.model?.id).toBe("openai/gpt-4o:extended");
-	});
-
-	test("does not strip invalid :suffix as thinking level in --model (treat as raw id)", () => {
-		const registry = {
-			getAll: () => allModels,
-		} as unknown as Parameters<typeof resolveCliModel>[0]["modelRegistry"];
-
-		const result = resolveCliModel({
-			cliProvider: "openai",
-			cliModel: "gpt-4o:extended",
-			modelRegistry: registry,
-		});
-
-		expect(result.error).toBeUndefined();
-		expect(result.model?.provider).toBe("openai");
-		expect(result.model?.id).toBe("gpt-4o:extended");
-	});
-
-	test("allows custom model ids for explicit providers without double prefixing", () => {
-		const registry = {
-			getAll: () => allModels,
-		} as unknown as Parameters<typeof resolveCliModel>[0]["modelRegistry"];
-
-		const result = resolveCliModel({
-			cliProvider: "openrouter",
-			cliModel: "openrouter/openai/ghost-model",
-			modelRegistry: registry,
-		});
-
-		expect(result.error).toBeUndefined();
-		expect(result.model?.provider).toBe("openrouter");
-		expect(result.model?.id).toBe("openai/ghost-model");
-	});
-
-	test("returns a clear error when there are no models", () => {
-		const registry = {
-			getAll: () => [],
-		} as unknown as Parameters<typeof resolveCliModel>[0]["modelRegistry"];
-
-		const result = resolveCliModel({
-			cliProvider: "openai",
-			cliModel: "gpt-4o",
-			modelRegistry: registry,
-		});
-
-		expect(result.model).toBeUndefined();
-		expect(result.error).toContain("No models available");
-	});
-
-	test("prefers provider/model split over gateway model with matching id", () => {
-		// When a user writes "zai/glm-5", and both a zai provider model (id: "glm-5")
-		// and a gateway model (id: "zai/glm-5") exist, prefer the zai provider model.
-		const zaiModel: Model<"anthropic-messages"> = {
-			id: "glm-5",
-			name: "GLM-5",
-			api: "anthropic-messages",
-			provider: "zai",
-			baseUrl: "https://open.bigmodel.cn/api/paas/v4",
-			reasoning: true,
-			input: ["text"],
-			cost: { input: 1, output: 2, cacheRead: 0.1, cacheWrite: 1 },
-			contextWindow: 128000,
-			maxTokens: 8192,
-		};
-		const gatewayModel: Model<"anthropic-messages"> = {
-			id: "zai/glm-5",
-			name: "GLM-5",
-			api: "anthropic-messages",
-			provider: "vercel-ai-gateway",
-			baseUrl: "https://ai-gateway.vercel.sh",
-			reasoning: true,
-			input: ["text"],
-			cost: { input: 1, output: 2, cacheRead: 0.1, cacheWrite: 1 },
-			contextWindow: 128000,
-			maxTokens: 8192,
-		};
-		const registry = {
-			getAll: () => [...allModels, zaiModel, gatewayModel],
-		} as unknown as Parameters<typeof resolveCliModel>[0]["modelRegistry"];
-
-		const result = resolveCliModel({
-			cliModel: "zai/glm-5",
-			modelRegistry: registry,
-		});
-
-		expect(result.error).toBeUndefined();
-		expect(result.model?.provider).toBe("zai");
-		expect(result.model?.id).toBe("glm-5");
-	});
-
-	test("resolves provider-prefixed fuzzy patterns (openrouter/qwen -> openrouter model)", () => {
-		const registry = {
-			getAll: () => allModels,
-		} as unknown as Parameters<typeof resolveCliModel>[0]["modelRegistry"];
-
-		const result = resolveCliModel({
-			cliModel: "openrouter/qwen",
-			modelRegistry: registry,
-		});
-
-		expect(result.error).toBeUndefined();
-		expect(result.model?.provider).toBe("openrouter");
-		expect(result.model?.id).toBe("qwen/qwen3-coder:exacto");
-	});
-});
-
-describe("default model selection", () => {
-	test("openai defaults are gpt-5.4", () => {
-		expect(defaultModelPerProvider.openai).toBe("gpt-5.4");
-		expect(defaultModelPerProvider["openai-codex"]).toBe("gpt-5.4");
-	});
-
-	test("zai, minimax, and cerebras defaults track current models", () => {
-		expect(defaultModelPerProvider.zai).toBe("glm-5");
-		expect(defaultModelPerProvider.minimax).toBe("MiniMax-M2.7");
-		expect(defaultModelPerProvider["minimax-cn"]).toBe("MiniMax-M2.7");
-		expect(defaultModelPerProvider.cerebras).toBe("zai-glm-4.7");
-	});
-
-	test("ai-gateway default is opus 4.6", () => {
-		expect(defaultModelPerProvider["vercel-ai-gateway"]).toBe("anthropic/claude-opus-4-6");
-	});
-
-	test("findInitialModel accepts explicit provider custom model ids", async () => {
-		const registry = {
-			getAll: () => allModels,
-		} as unknown as Parameters<typeof findInitialModel>[0]["modelRegistry"];
-
-		const result = await findInitialModel({
-			cliProvider: "openrouter",
-			cliModel: "openrouter/openai/ghost-model",
-			scopedModels: [],
-			isContinuing: false,
-			modelRegistry: registry,
-		});
-
-		expect(result.model?.provider).toBe("openrouter");
-		expect(result.model?.id).toBe("openai/ghost-model");
-	});
-
-	test("findInitialModel selects ai-gateway default when available", async () => {
-		const aiGatewayModel: Model<"anthropic-messages"> = {
-			id: "anthropic/claude-opus-4-6",
-			name: "Claude Opus 4.6",
-			api: "anthropic-messages",
-			provider: "vercel-ai-gateway",
-			baseUrl: "https://ai-gateway.vercel.sh",
-			reasoning: true,
-			input: ["text", "image"],
-			cost: { input: 5, output: 15, cacheRead: 0.5, cacheWrite: 5 },
-			contextWindow: 200000,
-			maxTokens: 8192,
-		};
-
-		const registry = {
-			getAvailable: async () => [aiGatewayModel],
-		} as unknown as Parameters<typeof findInitialModel>[0]["modelRegistry"];
-
-		const result = await findInitialModel({
-			scopedModels: [],
-			isContinuing: false,
-			modelRegistry: registry,
-		});
-
-		expect(result.model?.provider).toBe("vercel-ai-gateway");
-		expect(result.model?.id).toBe("anthropic/claude-opus-4-6");
-	});
-});

package/pi.dev-src/pi-mono/coding-agent/test/package-command-paths.test.ts

@@ -1,144 +0,0 @@
-import { mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { ENV_AGENT_DIR } from "../src/config.js";
-import { main } from "../src/main.js";
-
-describe("package commands", () => {
-	let tempDir: string;
-	let agentDir: string;
-	let projectDir: string;
-	let packageDir: string;
-	let originalCwd: string;
-	let originalAgentDir: string | undefined;
-	let originalExitCode: typeof process.exitCode;
-
-	beforeEach(() => {
-		tempDir = join(tmpdir(), `pi-package-commands-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-		agentDir = join(tempDir, "agent");
-		projectDir = join(tempDir, "project");
-		packageDir = join(tempDir, "local-package");
-		mkdirSync(agentDir, { recursive: true });
-		mkdirSync(projectDir, { recursive: true });
-		mkdirSync(packageDir, { recursive: true });
-
-		originalCwd = process.cwd();
-		originalAgentDir = process.env[ENV_AGENT_DIR];
-		originalExitCode = process.exitCode;
-		process.exitCode = undefined;
-		process.env[ENV_AGENT_DIR] = agentDir;
-		process.chdir(projectDir);
-	});
-
-	afterEach(() => {
-		process.chdir(originalCwd);
-		process.exitCode = originalExitCode;
-		if (originalAgentDir === undefined) {
-			delete process.env[ENV_AGENT_DIR];
-		} else {
-			process.env[ENV_AGENT_DIR] = originalAgentDir;
-		}
-		rmSync(tempDir, { recursive: true, force: true });
-	});
-
-	it("should persist global relative local package paths relative to settings.json", async () => {
-		const relativePkgDir = join(projectDir, "packages", "local-package");
-		mkdirSync(relativePkgDir, { recursive: true });
-
-		await main(["install", "./packages/local-package"]);
-
-		const settingsPath = join(agentDir, "settings.json");
-		const settings = JSON.parse(readFileSync(settingsPath, "utf-8")) as { packages?: string[] };
-		expect(settings.packages?.length).toBe(1);
-		const stored = settings.packages?.[0] ?? "";
-		const resolvedFromSettings = realpathSync(join(agentDir, stored));
-		expect(resolvedFromSettings).toBe(realpathSync(relativePkgDir));
-	});
-
-	it("should remove local packages using a path with a trailing slash", async () => {
-		await main(["install", `${packageDir}/`]);
-
-		const settingsPath = join(agentDir, "settings.json");
-		const installedSettings = JSON.parse(readFileSync(settingsPath, "utf-8")) as { packages?: string[] };
-		expect(installedSettings.packages?.length).toBe(1);
-
-		await main(["remove", `${packageDir}/`]);
-
-		const removedSettings = JSON.parse(readFileSync(settingsPath, "utf-8")) as { packages?: string[] };
-		expect(removedSettings.packages ?? []).toHaveLength(0);
-	});
-
-	it("shows install subcommand help", async () => {
-		const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
-		const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-
-		try {
-			await expect(main(["install", "--help"])).resolves.toBeUndefined();
-
-			const stdout = logSpy.mock.calls.map(([message]) => String(message)).join("\n");
-			expect(stdout).toContain("Usage:");
-			expect(stdout).toContain("pi install <source> [-l]");
-			expect(errorSpy).not.toHaveBeenCalled();
-			expect(process.exitCode).toBeUndefined();
-		} finally {
-			logSpy.mockRestore();
-			errorSpy.mockRestore();
-		}
-	});
-
-	it("shows a friendly error for unknown install options", async () => {
-		const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-
-		try {
-			await expect(main(["install", "--unknown"])).resolves.toBeUndefined();
-
-			const stderr = errorSpy.mock.calls.map(([message]) => String(message)).join("\n");
-			expect(stderr).toContain('Unknown option --unknown for "install".');
-			expect(stderr).toContain('Use "pi --help" or "pi install <source> [-l]".');
-			expect(process.exitCode).toBe(1);
-		} finally {
-			errorSpy.mockRestore();
-		}
-	});
-
-	it("shows a friendly error for missing install source", async () => {
-		const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-
-		try {
-			await expect(main(["install"])).resolves.toBeUndefined();
-
-			const stderr = errorSpy.mock.calls.map(([message]) => String(message)).join("\n");
-			expect(stderr).toContain("Missing install source.");
-			expect(stderr).toContain("Usage: pi install <source> [-l]");
-			expect(stderr).not.toContain("at ");
-			expect(process.exitCode).toBe(1);
-		} finally {
-			errorSpy.mockRestore();
-		}
-	});
-
-	it("suggests the configured source when update input omits the npm prefix", async () => {
-		const settingsPath = join(agentDir, "settings.json");
-		writeFileSync(settingsPath, JSON.stringify({ packages: ["npm:pi-formatter"] }, null, 2));
-
-		const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-		const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
-
-		try {
-			await expect(main(["update", "pi-formatter"])).resolves.toBeUndefined();
-
-			const stderr = errorSpy.mock.calls.map(([message]) => String(message)).join("\n");
-			const stdout = logSpy.mock.calls.map(([message]) => String(message)).join("\n");
-			expect(stderr).toContain("Did you mean npm:pi-formatter?");
-			expect(stdout).not.toContain("Updated pi-formatter");
-			expect(process.exitCode).toBe(1);
-
-			const settings = JSON.parse(readFileSync(settingsPath, "utf-8")) as { packages?: string[] };
-			expect(settings.packages).toContain("npm:pi-formatter");
-		} finally {
-			errorSpy.mockRestore();
-			logSpy.mockRestore();
-		}
-	});
-});

package/pi.dev-src/pi-mono/coding-agent/test/package-manager-ssh.test.ts

@@ -1,97 +0,0 @@
-import { mkdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { DefaultPackageManager } from "../src/core/package-manager.js";
-import { SettingsManager } from "../src/core/settings-manager.js";
-
-describe("Package Manager git source parsing", () => {
-	let tempDir: string;
-	let agentDir: string;
-	let settingsManager: SettingsManager;
-	let packageManager: DefaultPackageManager;
-
-	beforeEach(() => {
-		tempDir = join(tmpdir(), `pm-ssh-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-		mkdirSync(tempDir, { recursive: true });
-		agentDir = join(tempDir, "agent");
-		mkdirSync(agentDir, { recursive: true });
-
-		settingsManager = SettingsManager.inMemory();
-		packageManager = new DefaultPackageManager({
-			cwd: tempDir,
-			agentDir,
-			settingsManager,
-		});
-	});
-
-	afterEach(() => {
-		rmSync(tempDir, { recursive: true, force: true });
-	});
-
-	describe("protocol URLs without git: prefix", () => {
-		it("should parse https:// URL", () => {
-			const parsed = (packageManager as any).parseSource("https://github.com/user/repo");
-			expect(parsed.type).toBe("git");
-			expect(parsed.host).toBe("github.com");
-			expect(parsed.path).toBe("user/repo");
-		});
-
-		it("should parse ssh:// URL", () => {
-			const parsed = (packageManager as any).parseSource("ssh://git@github.com/user/repo");
-			expect(parsed.type).toBe("git");
-			expect(parsed.host).toBe("github.com");
-			expect(parsed.path).toBe("user/repo");
-			expect(parsed.repo).toBe("ssh://git@github.com/user/repo");
-		});
-	});
-
-	describe("shorthand URLs with git: prefix", () => {
-		it("should parse git@host:path format", () => {
-			const parsed = (packageManager as any).parseSource("git:git@github.com:user/repo");
-			expect(parsed.type).toBe("git");
-			expect(parsed.host).toBe("github.com");
-			expect(parsed.path).toBe("user/repo");
-			expect(parsed.repo).toBe("git@github.com:user/repo");
-			expect(parsed.pinned).toBe(false);
-		});
-
-		it("should parse host/path shorthand", () => {
-			const parsed = (packageManager as any).parseSource("git:github.com/user/repo");
-			expect(parsed.type).toBe("git");
-			expect(parsed.host).toBe("github.com");
-			expect(parsed.path).toBe("user/repo");
-		});
-
-		it("should parse shorthand with ref", () => {
-			const parsed = (packageManager as any).parseSource("git:git@github.com:user/repo@v1.0.0");
-			expect(parsed.type).toBe("git");
-			expect(parsed.ref).toBe("v1.0.0");
-			expect(parsed.pinned).toBe(true);
-		});
-	});
-
-	describe("unsupported without git: prefix", () => {
-		it("should treat git@host:path as local without git: prefix", () => {
-			const parsed = (packageManager as any).parseSource("git@github.com:user/repo");
-			expect(parsed.type).toBe("local");
-		});
-
-		it("should treat host/path shorthand as local without git: prefix", () => {
-			const parsed = (packageManager as any).parseSource("github.com/user/repo");
-			expect(parsed.type).toBe("local");
-		});
-	});
-
-	describe("identity normalization", () => {
-		it("should normalize protocol and shorthand-prefixed URLs to same identity", () => {
-			const prefixed = (packageManager as any).getPackageIdentity("git:git@github.com:user/repo");
-			const https = (packageManager as any).getPackageIdentity("https://github.com/user/repo");
-			const ssh = (packageManager as any).getPackageIdentity("ssh://git@github.com/user/repo");
-
-			expect(prefixed).toBe("git:github.com/user/repo");
-			expect(prefixed).toBe(https);
-			expect(prefixed).toBe(ssh);
-		});
-	});
-});