pi-usereq 0.7.0 → 0.11.0

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

@@ -0,0 +1,436 @@
+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

@@ -0,0 +1,144 @@
+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

@@ -0,0 +1,97 @@
+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);
+		});
+	});
+});