@foundation0/api 1.1.7 → 1.1.10

package/mcp/server.test.ts

@@ -204,7 +204,8 @@ describe("createExampleMcpServer request handling", () => {
 		}
 	});
 
-	it("accepts repoName for projects tools (preferred over legacy repoRoot/processRoot)", async () => {
+	it("accepts repoName selectors in short and owner/repo format", async () => {
+		const originalCwd = process.cwd();
 		const tempDir = await fs.mkdtemp(
 			path.join(os.tmpdir(), "f0-mcp-server-reponame-"),
 		);
@@ -216,36 +217,64 @@ describe("createExampleMcpServer request handling", () => {
 			await fs.mkdir(path.join(tempDir, "projects", "beta", "docs"), {
 				recursive: true,
 			});
+			await fs.mkdir(path.join(tempDir, ".git"), { recursive: true });
+			await fs.writeFile(
+				path.join(tempDir, ".git", "config"),
+				[
+					'[remote "origin"]',
+					"\turl = https://example.com/F0/adl.git",
+					"",
+				].join("\n"),
+			);
 
-			const instance = createExampleMcpServer({ repoRoot: tempDir, repoName: "test" });
+			process.chdir(tempDir);
+			const instance = createExampleMcpServer();
 			const handler = getToolHandler(instance);
 
-			const result = await handler(
+			const shortSelector = await handler(
 				{
 					method: "tools/call",
 					params: {
 						name: "projects.listProjects",
 						arguments: {
-							repoName: "test",
+							repoName: "adl",
 						},
 					},
 				},
 				{},
 			);
+			expect(shortSelector.isError).toBe(false);
+			const shortPayload = JSON.parse(shortSelector.content?.[0]?.text ?? "{}");
+			expect(shortPayload.ok).toBe(true);
+			expect(shortPayload.result).toContain("adl");
+			expect(shortPayload.result).toContain("beta");
 
-			expect(result.isError).toBe(false);
-			const payload = JSON.parse(result.content?.[0]?.text ?? "{}");
-			expect(payload.ok).toBe(true);
-			expect(payload.result).toContain("adl");
-			expect(payload.result).toContain("beta");
+			const fullSelector = await handler(
+				{
+					method: "tools/call",
+					params: {
+						name: "projects.listProjects",
+						arguments: {
+							repoName: "F0/adl",
+						},
+					},
+				},
+				{},
+			);
+			expect(fullSelector.isError).toBe(false);
+			const fullPayload = JSON.parse(fullSelector.content?.[0]?.text ?? "{}");
+			expect(fullPayload.ok).toBe(true);
+			expect(fullPayload.result).toContain("adl");
+			expect(fullPayload.result).toContain("beta");
 		} finally {
+			process.chdir(originalCwd);
 			await fs.rm(tempDir, { recursive: true, force: true });
 		}
 	});
 
-	it("auto-detects repoRoot from process.cwd() when repoName is omitted", async () => {
+	it("auto-detects Git workspace from process.cwd() when repoName is omitted", async () => {
 		const tempDir = await fs.mkdtemp(
-			path.join(os.tmpdir(), "f0-mcp-server-autoreporoot-"),
+			path.join(os.tmpdir(), "f0-mcp-server-autoworkspace-"),
 		);
 		const originalCwd = process.cwd();
 
@@ -257,6 +286,15 @@ describe("createExampleMcpServer request handling", () => {
 			await fs.mkdir(path.join(tempDir, "projects", "beta", "docs"), {
 				recursive: true,
 			});
+			await fs.mkdir(path.join(tempDir, ".git"), { recursive: true });
+			await fs.writeFile(
+				path.join(tempDir, ".git", "config"),
+				[
+					'[remote "origin"]',
+					"\turl = https://example.com/F0/adl.git",
+					"",
+				].join("\n"),
+			);
 
 			process.chdir(tempDir);
 
@@ -285,16 +323,35 @@ describe("createExampleMcpServer request handling", () => {
 		}
 	});
 
-	it("still accepts legacy processRoot for backwards compatibility", async () => {
-		const tempDir = await fs.mkdtemp(
-			path.join(os.tmpdir(), "f0-mcp-server-processroot-"),
+	it("ignores legacy processRoot/repoRoot payload fields and uses Git workspace", async () => {
+		const originalCwd = process.cwd();
+		const workspaceA = await fs.mkdtemp(
+			path.join(os.tmpdir(), "f0-mcp-server-legacy-fields-a-"),
+		);
+		const workspaceB = await fs.mkdtemp(
+			path.join(os.tmpdir(), "f0-mcp-server-legacy-fields-b-"),
 		);
 		try {
-			await fs.mkdir(path.join(tempDir, "api"), { recursive: true });
-			await fs.mkdir(path.join(tempDir, "projects", "adl", "docs"), {
+			await fs.mkdir(path.join(workspaceA, "api"), { recursive: true });
+			await fs.mkdir(path.join(workspaceA, "projects", "adl", "docs"), {
+				recursive: true,
+			});
+			await fs.mkdir(path.join(workspaceA, ".git"), { recursive: true });
+			await fs.writeFile(
+				path.join(workspaceA, ".git", "config"),
+				[
+					'[remote "origin"]',
+					"\turl = https://example.com/F0/adl.git",
+					"",
+				].join("\n"),
+			);
+
+			await fs.mkdir(path.join(workspaceB, "api"), { recursive: true });
+			await fs.mkdir(path.join(workspaceB, "projects", "beta", "docs"), {
 				recursive: true,
 			});
 
+			process.chdir(workspaceA);
 			const instance = createExampleMcpServer();
 			const handler = getToolHandler(instance);
 
@@ -304,7 +361,8 @@ describe("createExampleMcpServer request handling", () => {
 					params: {
 						name: "projects.listProjects",
 						arguments: {
-							processRoot: tempDir,
+							processRoot: workspaceB,
+							repoRoot: workspaceB,
 						},
 					},
 				},
@@ -315,24 +373,35 @@ describe("createExampleMcpServer request handling", () => {
 			const payload = JSON.parse(result.content?.[0]?.text ?? "{}");
 			expect(payload.ok).toBe(true);
 			expect(payload.result).toContain("adl");
+			expect(payload.result).not.toContain("beta");
 		} finally {
-			await fs.rm(tempDir, { recursive: true, force: true });
+			process.chdir(originalCwd);
+			await fs.rm(workspaceA, { recursive: true, force: true });
+			await fs.rm(workspaceB, { recursive: true, force: true });
 		}
 	});
 
-	it("normalizes legacy repoRoot when caller accidentally passes a project root", async () => {
+	it("exposes mcp.workspace with Git workspace context", async () => {
+		const originalCwd = process.cwd();
 		const tempDir = await fs.mkdtemp(
-			path.join(os.tmpdir(), "f0-mcp-server-reporoot-normalize-"),
+			path.join(os.tmpdir(), "f0-mcp-server-workspace-"),
 		);
 		try {
 			await fs.mkdir(path.join(tempDir, "api"), { recursive: true });
 			await fs.mkdir(path.join(tempDir, "projects", "adl", "docs"), {
 				recursive: true,
 			});
-			await fs.mkdir(path.join(tempDir, "projects", "beta", "docs"), {
-				recursive: true,
-			});
+			await fs.mkdir(path.join(tempDir, ".git"), { recursive: true });
+			await fs.writeFile(
+				path.join(tempDir, ".git", "config"),
+				[
+					'[remote "origin"]',
+					"\turl = https://example.com/F0/adl.git",
+					"",
+				].join("\n"),
+			);
 
+			process.chdir(tempDir);
 			const instance = createExampleMcpServer();
 			const handler = getToolHandler(instance);
 
@@ -340,10 +409,8 @@ describe("createExampleMcpServer request handling", () => {
 				{
 					method: "tools/call",
 					params: {
-						name: "projects.listProjects",
-						arguments: {
-							repoRoot: path.join(tempDir, "projects", "adl"),
-						},
+						name: "mcp.workspace",
+						arguments: {},
 					},
 				},
 				{},
@@ -352,64 +419,114 @@ describe("createExampleMcpServer request handling", () => {
 			expect(result.isError).toBe(false);
 			const payload = JSON.parse(result.content?.[0]?.text ?? "{}");
 			expect(payload.ok).toBe(true);
-			expect(payload.result).toContain("adl");
-			expect(payload.result).toContain("beta");
+			expect(payload.result.workspaceRoot).toBe(path.resolve(tempDir));
+			expect(payload.result.processRoot).toBe(path.resolve(tempDir));
+			expect(payload.result.defaultRepoName).toBe("adl");
+			expect(payload.result.defaultRepoFullName).toBe("F0/adl");
+			expect(payload.result.availableRepoNames).toContain("adl");
+			expect(payload.result.availableRepoNames).toContain("F0/adl");
+			expect(payload.result.hasProjectsDir).toBe(true);
+			expect(Array.isArray(payload.result.projects)).toBe(true);
 		} finally {
+			process.chdir(originalCwd);
 			await fs.rm(tempDir, { recursive: true, force: true });
 		}
 	});
 
-	it("uses server default repoRoot when repoName is omitted", async () => {
+	it("auto-detects repo identity from .git/config when no repoName is provided", async () => {
+		const originalCwd = process.cwd();
 		const tempDir = await fs.mkdtemp(
-			path.join(os.tmpdir(), "f0-mcp-server-default-reporoot-"),
+			path.join(os.tmpdir(), "f0-mcp-server-git-detect-"),
 		);
 		try {
-			await fs.mkdir(path.join(tempDir, "api"), { recursive: true });
+			await fs.mkdir(path.join(tempDir, "api", "mcp"), { recursive: true });
 			await fs.mkdir(path.join(tempDir, "projects", "adl", "docs"), {
 				recursive: true,
 			});
-			await fs.mkdir(path.join(tempDir, "projects", "beta", "docs"), {
-				recursive: true,
-			});
+			await fs.mkdir(path.join(tempDir, ".git"), { recursive: true });
+			await fs.writeFile(
+				path.join(tempDir, ".git", "config"),
+				[
+					'[remote "origin"]',
+					"\turl = https://example.com/F0/adl.git",
+					"",
+				].join("\n"),
+			);
 
-			const instance = createExampleMcpServer({ repoRoot: tempDir });
+			process.chdir(path.join(tempDir, "api", "mcp"));
+			const instance = createExampleMcpServer();
 			const handler = getToolHandler(instance);
 
-			const result = await handler(
+			const workspace = await handler(
 				{
 					method: "tools/call",
 					params: {
-						name: "projects.listProjects",
+						name: "mcp.workspace",
 						arguments: {},
 					},
 				},
 				{},
 			);
 
-			expect(result.isError).toBe(false);
-			const payload = JSON.parse(result.content?.[0]?.text ?? "{}");
+			expect(workspace.isError).toBe(false);
+			const payload = JSON.parse(workspace.content?.[0]?.text ?? "{}");
 			expect(payload.ok).toBe(true);
-			expect(payload.result).toContain("adl");
-			expect(payload.result).toContain("beta");
+			expect(payload.result.workspaceRoot).toBe(path.resolve(tempDir));
+			expect(payload.result.processRoot).toBe(path.resolve(tempDir));
+			expect(payload.result.defaultRepoName).toBe("adl");
+			expect(payload.result.defaultRepoFullName).toBe("F0/adl");
+			expect(payload.result.repoName).toBe("adl");
+			expect(payload.result.availableRepoNames).toContain("adl");
+			expect(payload.result.availableRepoNames).toContain("F0/adl");
+
+			const list = await handler(
+				{
+					method: "tools/call",
+					params: {
+						name: "projects.listProjects",
+						arguments: {},
+					},
+				},
+				{},
+			);
+			expect(list.isError).toBe(false);
+			const listPayload = JSON.parse(list.content?.[0]?.text ?? "{}");
+			expect(listPayload.ok).toBe(true);
+			expect(listPayload.result).toContain("adl");
 		} finally {
+			process.chdir(originalCwd);
 			await fs.rm(tempDir, { recursive: true, force: true });
 		}
 	});
 
-	it("exposes mcp.workspace to explain server filesystem context", async () => {
+	it("supports worktree-style .git file (gitdir: ...) when deriving repoName from config", async () => {
+		const originalCwd = process.cwd();
 		const tempDir = await fs.mkdtemp(
-			path.join(os.tmpdir(), "f0-mcp-server-workspace-"),
+			path.join(os.tmpdir(), "f0-mcp-server-gitfile-detect-"),
 		);
 		try {
-			await fs.mkdir(path.join(tempDir, "api"), { recursive: true });
+			await fs.mkdir(path.join(tempDir, "api", "mcp"), { recursive: true });
 			await fs.mkdir(path.join(tempDir, "projects", "adl", "docs"), {
 				recursive: true,
 			});
 
-			const instance = createExampleMcpServer({ repoRoot: tempDir });
+			const gitDir = path.join(tempDir, ".gitdir");
+			await fs.mkdir(gitDir, { recursive: true });
+			await fs.writeFile(
+				path.join(gitDir, "config"),
+				[
+					'[remote "origin"]',
+					"\turl = git@github.com:F0/adl.git",
+					"",
+				].join("\n"),
+			);
+			await fs.writeFile(path.join(tempDir, ".git"), "gitdir: .gitdir\n");
+
+			process.chdir(path.join(tempDir, "api", "mcp"));
+			const instance = createExampleMcpServer();
 			const handler = getToolHandler(instance);
 
-			const result = await handler(
+			const workspace = await handler(
 				{
 					method: "tools/call",
 					params: {
@@ -420,14 +537,14 @@ describe("createExampleMcpServer request handling", () => {
 				{},
 			);
 
-			expect(result.isError).toBe(false);
-			const payload = JSON.parse(result.content?.[0]?.text ?? "{}");
+			expect(workspace.isError).toBe(false);
+			const payload = JSON.parse(workspace.content?.[0]?.text ?? "{}");
 			expect(payload.ok).toBe(true);
-			expect(payload.result.repoRoot).toBe(path.resolve(tempDir));
-			expect(payload.result.defaultRepoRoot).toBe(path.resolve(tempDir));
-			expect(payload.result.hasProjectsDir).toBe(true);
-			expect(Array.isArray(payload.result.projects)).toBe(true);
+			expect(payload.result.defaultRepoName).toBe("adl");
+			expect(payload.result.defaultRepoFullName).toBe("F0/adl");
+			expect(payload.result.availableRepoNames).toContain("F0/adl");
 		} finally {
+			process.chdir(originalCwd);
 			await fs.rm(tempDir, { recursive: true, force: true });
 		}
 	});