@foundation0/api 1.1.7 → 1.1.8

package/mcp/server.test.ts

@@ -432,6 +432,118 @@ describe("createExampleMcpServer request handling", () => {
 		}
 	});
 
+	it("auto-detects repo root/name from .git/config when no repoRoot/repoName are provided", async () => {
+		const originalCwd = process.cwd();
+		const tempDir = await fs.mkdtemp(
+			path.join(os.tmpdir(), "f0-mcp-server-git-detect-"),
+		);
+		try {
+			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, ".git"), { recursive: true });
+			await fs.writeFile(
+				path.join(tempDir, ".git", "config"),
+				[
+					'[remote "origin"]',
+					"\turl = https://example.com/F0/adl.git",
+					"",
+				].join("\n"),
+			);
+
+			process.chdir(path.join(tempDir, "api", "mcp"));
+			const instance = createExampleMcpServer();
+			const handler = getToolHandler(instance);
+
+			const workspace = await handler(
+				{
+					method: "tools/call",
+					params: {
+						name: "mcp.workspace",
+						arguments: {},
+					},
+				},
+				{},
+			);
+
+			expect(workspace.isError).toBe(false);
+			const payload = JSON.parse(workspace.content?.[0]?.text ?? "{}");
+			expect(payload.ok).toBe(true);
+			expect(payload.result.defaultRepoRoot).toBe(path.resolve(tempDir));
+			expect(payload.result.repoRoot).toBe(path.resolve(tempDir));
+			expect(payload.result.defaultRepoName).toBe("adl");
+			expect(payload.result.repoName).toBe("adl");
+			expect(payload.result.availableRepoNames).toContain("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("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-gitfile-detect-"),
+		);
+		try {
+			await fs.mkdir(path.join(tempDir, "api", "mcp"), { recursive: true });
+			await fs.mkdir(path.join(tempDir, "projects", "adl", "docs"), {
+				recursive: true,
+			});
+
+			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 workspace = await handler(
+				{
+					method: "tools/call",
+					params: {
+						name: "mcp.workspace",
+						arguments: {},
+					},
+				},
+				{},
+			);
+
+			expect(workspace.isError).toBe(false);
+			const payload = JSON.parse(workspace.content?.[0]?.text ?? "{}");
+			expect(payload.ok).toBe(true);
+			expect(payload.result.defaultRepoName).toBe("adl");
+		} finally {
+			process.chdir(originalCwd);
+			await fs.rm(tempDir, { recursive: true, force: true });
+		}
+	});
+
 	it('parses continueOnError from string "false" (fails fast)', async () => {
 		const instance = createExampleMcpServer();
 		const handler = getToolHandler(instance);

package/mcp/server.ts

@@ -9,6 +9,7 @@ import * as netApi from "../net.ts";
 import * as projectsApi from "../projects.ts";
 import fs from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 
 type ApiMethod = (...args: unknown[]) => unknown;
 type ToolInvocationPayload = {
@@ -176,6 +177,104 @@ const isDir = (candidate: string): boolean => {
 const looksLikeRepoRoot = (candidate: string): boolean =>
 	isDir(path.join(candidate, "projects")) && isDir(path.join(candidate, "api"));
 
+const fileExists = (candidate: string): boolean => {
+	try {
+		fs.statSync(candidate);
+		return true;
+	} catch {
+		return false;
+	}
+};
+
+const findGitRepoRoot = (startDir: string): string | null => {
+	let current = path.resolve(startDir);
+	for (let depth = 0; depth < 32; depth += 1) {
+		const dotGit = path.join(current, ".git");
+		if (isDir(dotGit) || fileExists(dotGit)) return current;
+		const parent = path.dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+	return null;
+};
+
+const resolveGitDir = (repoRoot: string): string | null => {
+	const dotGit = path.join(repoRoot, ".git");
+	if (isDir(dotGit)) return dotGit;
+	if (!fileExists(dotGit)) return null;
+
+	try {
+		const content = fs.readFileSync(dotGit, "utf8");
+		const match = content.match(/^\s*gitdir:\s*(.+)\s*$/im);
+		if (!match) return null;
+		const raw = match[1].trim();
+		if (!raw) return null;
+		const resolved = path.resolve(repoRoot, raw);
+		return isDir(resolved) ? resolved : null;
+	} catch {
+		return null;
+	}
+};
+
+const parseRepoNameFromRemoteUrl = (remoteUrl: string): string | null => {
+	const trimmed = remoteUrl.trim();
+	if (!trimmed) return null;
+
+	const withoutHash = trimmed.split("#")[0] ?? trimmed;
+	const withoutQuery = withoutHash.split("?")[0] ?? withoutHash;
+	const withoutGit = withoutQuery.endsWith(".git")
+		? withoutQuery.slice(0, -4)
+		: withoutQuery;
+
+	const lastSep = Math.max(withoutGit.lastIndexOf("/"), withoutGit.lastIndexOf(":"));
+	const candidate = (lastSep >= 0 ? withoutGit.slice(lastSep + 1) : withoutGit).trim();
+	if (!candidate) return null;
+	return candidate;
+};
+
+const readGitRemoteUrl = (gitDir: string): string | null => {
+	const configPath = path.join(gitDir, "config");
+	if (!fileExists(configPath)) return null;
+	try {
+		const config = fs.readFileSync(configPath, "utf8");
+		let currentRemote: string | null = null;
+		const remoteUrls = new Map<string, string>();
+
+		for (const rawLine of config.split(/\r?\n/)) {
+			const line = rawLine.trim();
+			if (!line || line.startsWith("#") || line.startsWith(";")) continue;
+
+			const sectionMatch = line.match(/^\[\s*([^\s\]]+)(?:\s+"([^"]+)")?\s*\]\s*$/);
+			if (sectionMatch) {
+				const section = sectionMatch[1].toLowerCase();
+				const name = sectionMatch[2] ?? null;
+				currentRemote = section === "remote" ? name : null;
+				continue;
+			}
+
+			if (!currentRemote) continue;
+			const kvMatch = line.match(/^([A-Za-z0-9][-A-Za-z0-9]*)\s*=\s*(.*)$/);
+			if (!kvMatch) continue;
+			const key = kvMatch[1].toLowerCase();
+			if (key !== "url") continue;
+			const value = kvMatch[2].trim().replace(/^"(.*)"$/, "$1").trim();
+			if (value) remoteUrls.set(currentRemote, value);
+		}
+
+		return remoteUrls.get("origin") ?? remoteUrls.values().next().value ?? null;
+	} catch {
+		return null;
+	}
+};
+
+const detectRepoNameFromGitConfig = (repoRoot: string): string | null => {
+	const gitDir = resolveGitDir(repoRoot);
+	if (!gitDir) return null;
+	const remoteUrl = readGitRemoteUrl(gitDir);
+	if (!remoteUrl) return null;
+	return parseRepoNameFromRemoteUrl(remoteUrl);
+};
+
 const normalizeRepoRoot = (raw: string): string => {
 	const resolved = path.resolve(raw);
 	if (looksLikeRepoRoot(resolved)) return resolved;
@@ -2162,15 +2261,34 @@ export const createExampleMcpServer = (
 	options: ExampleMcpServerOptions = {},
 ): ExampleMcpServerInstance => {
 	let toolCatalog: unknown[] = [];
-	const defaultRepoRoot = normalizeRepoRoot(
-		options.repoRoot ??
-			process.env.MCP_REPO_ROOT ??
-			process.env.F0_REPO_ROOT ??
-			process.cwd(),
-	);
-	const defaultRepoName =
+
+	const configuredRepoRoot =
+		options.repoRoot ?? process.env.MCP_REPO_ROOT ?? process.env.F0_REPO_ROOT;
+	const cwd = process.cwd();
+	const cwdNormalized = normalizeRepoRoot(cwd);
+	const cwdLooksLikeRepoRoot = looksLikeRepoRoot(cwdNormalized);
+	const cwdGitRoot = findGitRepoRoot(cwd);
+	const serverFileDir = path.dirname(fileURLToPath(import.meta.url));
+	const serverFileGitRoot = findGitRepoRoot(serverFileDir);
+
+	const rawDefaultRepoRoot =
+		configuredRepoRoot ??
+		(cwdLooksLikeRepoRoot ? cwdNormalized : null) ??
+		cwdGitRoot ??
+		serverFileGitRoot ??
+		cwd ??
+		serverFileDir;
+	const defaultRepoRoot = normalizeRepoRoot(rawDefaultRepoRoot);
+
+	const configuredRepoName =
 		(options.repoName ?? process.env.MCP_REPO_NAME ?? process.env.F0_REPO_NAME)?.trim() ||
-		path.basename(defaultRepoRoot);
+		null;
+	const gitDerivedRepoName =
+		detectRepoNameFromGitConfig(defaultRepoRoot) ??
+		(cwdGitRoot ? detectRepoNameFromGitConfig(cwdGitRoot) : null) ??
+		(serverFileGitRoot ? detectRepoNameFromGitConfig(serverFileGitRoot) : null);
+	const defaultRepoName =
+		configuredRepoName || gitDerivedRepoName || path.basename(defaultRepoRoot);
 	const repoMapRaw = process.env.MCP_REPOS ?? process.env.F0_REPOS;
 	const repoMap = {
 		...parseRepoMap(repoMapRaw),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foundation0/api",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "description": "Foundation 0 API",
   "type": "module",
   "bin": {