@oh-my-pi/pi-coding-agent 13.18.0 → 14.0.2

package/src/lsp/index.ts

@@ -1,9 +1,8 @@
 import * as fs from "node:fs";
 import path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { logger, once, untilAborted } from "@oh-my-pi/pi-utils";
+import { logger, once, prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import type { BunFile } from "bun";
-import { renderPromptTemplate } from "../config/prompt-templates";
 import { type Theme, theme } from "../modes/theme/theme";
 import lspDescription from "../prompts/tools/lsp.md" with { type: "text" };
 import type { ToolSession } from "../tools";
@@ -40,6 +39,7 @@ import {
 	type LspParams,
 	type LspToolDetails,
 	lspSchema,
+	type PublishedDiagnostics,
 	type ServerConfig,
 	type SymbolInformation,
 	type TextEdit,
@@ -71,14 +71,16 @@ import {
 export type { LspServerStatus } from "./client";
 export type { LspToolDetails } from "./types";
 
+export interface LspStartupServerInfo {
+	name: string;
+	status: "connecting" | "ready" | "error";
+	fileTypes: string[];
+	error?: string;
+}
+
 /** Result from warming up LSP servers */
 export interface LspWarmupResult {
-	servers: Array<{
-		name: string;
-		status: "ready" | "error";
-		fileTypes: string[];
-		error?: string;
-	}>;
+	servers: Array<LspStartupServerInfo & { status: "ready" | "error" }>;
 }
 
 /** Options for warming up LSP servers */
@@ -87,6 +89,15 @@ export interface LspWarmupOptions {
 	onConnecting?: (serverNames: string[]) => void;
 }
 
+export function discoverStartupLspServers(cwd: string): LspStartupServerInfo[] {
+	const config = loadConfig(cwd);
+	return getLspServers(config).map(([name, serverConfig]) => ({
+		name,
+		status: "connecting",
+		fileTypes: serverConfig.fileTypes,
+	}));
+}
+
 /**
  * Warm up LSP servers for a directory by connecting to all detected servers.
  * This should be called at startup to avoid cold-start delays.
@@ -312,22 +323,59 @@ async function reloadServer(client: LspClient, serverName: string, signal?: Abor
 	return output;
 }
 
+interface WaitForDiagnosticsOptions {
+	timeoutMs?: number;
+	signal?: AbortSignal;
+	minVersion?: number;
+	expectedDocumentVersion?: number;
+	allowUnversioned?: boolean;
+}
+
+function getAcceptedDiagnostics(
+	publishedDiagnostics: PublishedDiagnostics | undefined,
+	expectedDocumentVersion?: number,
+	allowUnversioned = true,
+): Diagnostic[] | undefined {
+	if (!publishedDiagnostics) {
+		return undefined;
+	}
+	if (expectedDocumentVersion === undefined) {
+		return publishedDiagnostics.diagnostics;
+	}
+	if (publishedDiagnostics.version === expectedDocumentVersion) {
+		return publishedDiagnostics.diagnostics;
+	}
+	if (allowUnversioned && publishedDiagnostics.version == null) {
+		return publishedDiagnostics.diagnostics;
+	}
+	return undefined;
+}
+
 async function waitForDiagnostics(
 	client: LspClient,
 	uri: string,
-	timeoutMs = 3000,
-	signal?: AbortSignal,
-	minVersion?: number,
+	options: WaitForDiagnosticsOptions = {},
 ): Promise<Diagnostic[]> {
+	const { timeoutMs = 3000, signal, minVersion, expectedDocumentVersion, allowUnversioned = true } = options;
 	const start = Date.now();
 	while (Date.now() - start < timeoutMs) {
 		throwIfAborted(signal);
-		const diagnostics = client.diagnostics.get(uri);
 		const versionOk = minVersion === undefined || client.diagnosticsVersion > minVersion;
-		if (diagnostics !== undefined && versionOk) return diagnostics;
+		const diagnostics = getAcceptedDiagnostics(
+			client.diagnostics.get(uri),
+			expectedDocumentVersion,
+			allowUnversioned,
+		);
+		if (diagnostics !== undefined && versionOk) {
+			return diagnostics;
+		}
 		await Bun.sleep(100);
 	}
-	return client.diagnostics.get(uri) ?? [];
+	const versionOk = minVersion === undefined || client.diagnosticsVersion > minVersion;
+	if (!versionOk) {
+		return [];
+	}
+	return getAcceptedDiagnostics(client.diagnostics.get(uri), expectedDocumentVersion, allowUnversioned) ?? [];
 }
 
 /** Project type detection result */
@@ -426,8 +474,14 @@ export interface FileDiagnosticsResult {
 	formatter?: FileFormatResult;
 }
 
-/** Captured diagnostic versions per server (before sync) */
-type DiagnosticVersions = Map<string, number>;
+type ServerVersionMap = Map<string, number>;
+
+interface GetDiagnosticsForFileOptions {
+	signal?: AbortSignal;
+	minVersions?: ServerVersionMap;
+	expectedDocumentVersions?: ServerVersionMap;
+	allowUnversionedLspDiagnostics?: boolean;
+}
 
 /**
  * Capture current diagnostic versions for all LSP servers.
@@ -436,7 +490,7 @@ type DiagnosticVersions = Map<string, number>;
 async function captureDiagnosticVersions(
 	cwd: string,
 	servers: Array<[string, ServerConfig]>,
-): Promise<DiagnosticVersions> {
+): Promise<ServerVersionMap> {
 	const versions = new Map<string, number>();
 	await Promise.allSettled(
 		servers.map(async ([serverName, serverConfig]) => {
@@ -448,6 +502,25 @@ async function captureDiagnosticVersions(
 	return versions;
 }
 
+async function captureOpenFileVersions(
+	absolutePath: string,
+	cwd: string,
+	servers: Array<[string, ServerConfig]>,
+): Promise<ServerVersionMap> {
+	const uri = fileToUri(absolutePath);
+	const versions = new Map<string, number>();
+	await Promise.allSettled(
+		servers.map(async ([serverName, serverConfig]) => {
+			const client = await getOrCreateClient(serverConfig, cwd);
+			const version = client.openFiles.get(uri)?.version;
+			if (version !== undefined) {
+				versions.set(serverName, version);
+			}
+		}),
+	);
+	return versions;
+}
+
 /**
  * Get diagnostics for a file using LSP or custom linter client.
  *
@@ -461,9 +534,9 @@ async function getDiagnosticsForFile(
 	absolutePath: string,
 	cwd: string,
 	servers: Array<[string, ServerConfig]>,
-	signal?: AbortSignal,
-	minVersions?: DiagnosticVersions,
+	options: GetDiagnosticsForFileOptions = {},
 ): Promise<FileDiagnosticsResult | undefined> {
+	const { signal, minVersions, expectedDocumentVersions, allowUnversionedLspDiagnostics = true } = options;
 	if (servers.length === 0) {
 		return undefined;
 	}
@@ -489,7 +562,14 @@ async function getDiagnosticsForFile(
 			throwIfAborted(signal);
 			// Content already synced + didSave sent, wait for fresh diagnostics
 			const minVersion = minVersions?.get(serverName);
-			const diagnostics = await waitForDiagnostics(client, uri, 3000, signal, minVersion);
+			const expectedDocumentVersion = expectedDocumentVersions?.get(serverName);
+			const diagnostics = await waitForDiagnostics(client, uri, {
+				timeoutMs: 3000,
+				signal,
+				minVersion,
+				expectedDocumentVersion,
+				allowUnversioned: allowUnversionedLspDiagnostics,
+			});
 			return { serverName, diagnostics };
 		}),
 	);
@@ -622,8 +702,25 @@ export interface WritethroughOptions {
 	enableFormat?: boolean;
 	/** Whether to get LSP diagnostics after writing */
 	enableDiagnostics?: boolean;
+	/** Called when diagnostics arrive after the main timeout. */
+	onDeferredDiagnostics?: (diagnostics: FileDiagnosticsResult) => void;
+	/** Signal to cancel a pending deferred diagnostics fetch. */
+	deferredSignal?: AbortSignal;
 }
 
+/** Internal resolved form of {@link WritethroughOptions} that the writethrough machinery operates on. */
+type ResolvedWritethroughOptions = {
+	enableFormat: boolean;
+	enableDiagnostics: boolean;
+};
+
+/** Per-file deferred LSP diagnostics wiring for {@link WritethroughCallback}. */
+export type WritethroughDeferredHandle = {
+	onDeferredDiagnostics: (diagnostics: FileDiagnosticsResult) => void;
+	signal: AbortSignal;
+	finalize: (diagnostics: FileDiagnosticsResult | undefined) => void;
+};
+
 /** Callback type for the LSP writethrough */
 export type WritethroughCallback = (
 	dst: string,
@@ -631,6 +728,7 @@ export type WritethroughCallback = (
 	signal?: AbortSignal,
 	file?: BunFile,
 	batch?: LspWritethroughBatchRequest,
+	getDeferred?: (dst: string) => WritethroughDeferredHandle | undefined,
 ) => Promise<FileDiagnosticsResult | undefined>;
 
 /** No-op writethrough callback */
@@ -639,6 +737,8 @@ export async function writethroughNoop(
 	content: string,
 	_signal?: AbortSignal,
 	file?: BunFile,
+	_batch?: LspWritethroughBatchRequest,
+	_getDeferred?: (dst: string) => WritethroughDeferredHandle | undefined,
 ): Promise<FileDiagnosticsResult | undefined> {
 	if (file) {
 		await file.write(content);
@@ -661,12 +761,12 @@ interface LspWritethroughBatchRequest {
 
 interface LspWritethroughBatchState {
 	entries: Map<string, PendingWritethrough>;
-	options: Required<WritethroughOptions>;
+	options: ResolvedWritethroughOptions;
 }
 
 const writethroughBatches = new Map<string, LspWritethroughBatchState>();
 
-function getOrCreateWritethroughBatch(id: string, options: Required<WritethroughOptions>): LspWritethroughBatchState {
+function getOrCreateWritethroughBatch(id: string, options: ResolvedWritethroughOptions): LspWritethroughBatchState {
 	const existing = writethroughBatches.get(id);
 	if (existing) {
 		existing.options.enableFormat ||= options.enableFormat;
@@ -717,7 +817,7 @@ function summarizeDiagnosticMessages(messages: string[]): { summary: string; err
 
 function mergeDiagnostics(
 	results: Array<FileDiagnosticsResult | undefined>,
-	options: Required<WritethroughOptions>,
+	options: ResolvedWritethroughOptions,
 ): FileDiagnosticsResult | undefined {
 	const messages: string[] = [];
 	const servers = new Set<string>();
@@ -771,13 +871,41 @@ function mergeDiagnostics(
 	};
 }
 
+async function scheduleDeferredDiagnosticsFetch(args: {
+	dst: string;
+	cwd: string;
+	servers: Array<[string, ServerConfig]>;
+	minVersions: ServerVersionMap | undefined;
+	expectedDocumentVersions: ServerVersionMap | undefined;
+	signal: AbortSignal;
+	callback: (diagnostics: FileDiagnosticsResult) => void;
+}): Promise<void> {
+	try {
+		const deferredTimeout = AbortSignal.timeout(25_000);
+		const combined = AbortSignal.any([args.signal, deferredTimeout]);
+		const diagnostics = await getDiagnosticsForFile(args.dst, args.cwd, args.servers, {
+			signal: combined,
+			minVersions: args.minVersions,
+			expectedDocumentVersions: args.expectedDocumentVersions,
+		});
+		if (args.signal.aborted || diagnostics === undefined) return;
+		args.callback(diagnostics);
+	} catch {
+		// Cancelled or LSP gave up; silently discard.
+	}
+}
+
 async function runLspWritethrough(
 	dst: string,
 	content: string,
 	cwd: string,
-	options: Required<WritethroughOptions>,
+	options: ResolvedWritethroughOptions,
 	signal?: AbortSignal,
 	file?: BunFile,
+	deferred?: {
+		onDeferredDiagnostics: (diagnostics: FileDiagnosticsResult) => void;
+		signal: AbortSignal;
+	},
 ): Promise<FileDiagnosticsResult | undefined> {
 	const { enableFormat, enableDiagnostics } = options;
 	const config = getConfig(cwd);
@@ -794,12 +922,13 @@ async function runLspWritethrough(
 
 	// Capture diagnostic versions BEFORE syncing to detect stale diagnostics
 	const minVersions = enableDiagnostics ? await captureDiagnosticVersions(cwd, servers) : undefined;
+	let expectedDocumentVersions: ServerVersionMap | undefined;
 
 	let formatter: FileFormatResult | undefined;
 	let diagnostics: FileDiagnosticsResult | undefined;
 	let timedOut = false;
 	try {
-		const timeoutSignal = AbortSignal.timeout(10_000);
+		const timeoutSignal = AbortSignal.timeout(5_000);
 		timeoutSignal.addEventListener(
 			"abort",
 			() => {
@@ -835,18 +964,39 @@ async function runLspWritethrough(
 				await getWritePromise();
 			}
 
+			if (enableDiagnostics) {
+				expectedDocumentVersions = await captureOpenFileVersions(dst, cwd, lspServers);
+			}
+
 			// 5. Notify saved to LSP servers
 			await notifyFileSaved(dst, cwd, lspServers, operationSignal);
 
 			// 6. Get diagnostics from all servers (wait for fresh results)
 			if (enableDiagnostics) {
-				diagnostics = await getDiagnosticsForFile(dst, cwd, servers, operationSignal, minVersions);
+				diagnostics = await getDiagnosticsForFile(dst, cwd, servers, {
+					signal: operationSignal,
+					minVersions,
+					expectedDocumentVersions,
+					allowUnversionedLspDiagnostics: false,
+				});
 			}
 		});
 	} catch {
 		if (timedOut) {
 			formatter = undefined;
 			diagnostics = undefined;
+			// Schedule background diagnostic fetch if caller wants deferred results
+			if (deferred && !deferred.signal.aborted && enableDiagnostics) {
+				void scheduleDeferredDiagnosticsFetch({
+					dst,
+					cwd,
+					servers,
+					minVersions,
+					expectedDocumentVersions,
+					signal: deferred.signal,
+					callback: deferred.onDeferredDiagnostics,
+				});
+			}
 		}
 		await getWritePromise();
 	}
@@ -867,22 +1017,32 @@ async function runLspWritethrough(
 async function flushWritethroughBatch(
 	batch: PendingWritethrough[],
 	cwd: string,
-	options: Required<WritethroughOptions>,
+	options: ResolvedWritethroughOptions,
 	signal?: AbortSignal,
+	getDeferred?: (dst: string) => WritethroughDeferredHandle | undefined,
 ): Promise<FileDiagnosticsResult | undefined> {
 	if (batch.length === 0) {
 		return undefined;
 	}
 	const results: Array<FileDiagnosticsResult | undefined> = [];
 	for (const entry of batch) {
-		results.push(await runLspWritethrough(entry.dst, entry.content, cwd, options, signal, entry.file));
+		const bundle = getDeferred?.(entry.dst);
+		const deferredInner =
+			bundle &&
+			({
+				onDeferredDiagnostics: bundle.onDeferredDiagnostics,
+				signal: bundle.signal,
+			} as const);
+		const diag = await runLspWritethrough(entry.dst, entry.content, cwd, options, signal, entry.file, deferredInner);
+		bundle?.finalize(diag);
+		results.push(diag);
 	}
 	return mergeDiagnostics(results, options);
 }
 
 /** Create a writethrough callback for LSP aware write operations */
 export function createLspWritethrough(cwd: string, options?: WritethroughOptions): WritethroughCallback {
-	const resolvedOptions: Required<WritethroughOptions> = {
+	const resolvedOptions: ResolvedWritethroughOptions = {
 		enableFormat: options?.enableFormat ?? false,
 		enableDiagnostics: options?.enableDiagnostics ?? false,
 	};
@@ -895,9 +1055,19 @@ export function createLspWritethrough(cwd: string, options?: WritethroughOptions
 		signal?: AbortSignal,
 		file?: BunFile,
 		batch?: LspWritethroughBatchRequest,
+		getDeferred?: (dst: string) => WritethroughDeferredHandle | undefined,
 	) => {
 		if (!batch) {
-			return runLspWritethrough(dst, content, cwd, resolvedOptions, signal, file);
+			const bundle = getDeferred?.(dst);
+			const deferredInner =
+				bundle &&
+				({
+					onDeferredDiagnostics: bundle.onDeferredDiagnostics,
+					signal: bundle.signal,
+				} as const);
+			const diagnostics = await runLspWritethrough(dst, content, cwd, resolvedOptions, signal, file, deferredInner);
+			bundle?.finalize(diagnostics);
+			return diagnostics;
 		}
 
 		const state = getOrCreateWritethroughBatch(batch.id, resolvedOptions);
@@ -909,7 +1079,7 @@ export function createLspWritethrough(cwd: string, options?: WritethroughOptions
 		}
 
 		writethroughBatches.delete(batch.id);
-		return flushWritethroughBatch(Array.from(state.entries.values()), cwd, state.options, signal);
+		return flushWritethroughBatch(Array.from(state.entries.values()), cwd, state.options, signal, getDeferred);
 	};
 }
 
@@ -928,7 +1098,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 	readonly inline = true;
 
 	constructor(private readonly session: ToolSession) {
-		this.description = renderPromptTemplate(lspDescription);
+		this.description = prompt.render(lspDescription);
 	}
 
 	static createIf(session: ToolSession): LspTool | null {
@@ -974,8 +1144,8 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 
 		// Diagnostics can be batch or single-file - queries all applicable servers
 		if (action === "diagnostics") {
-			if (!file) {
-				// No file specified - run workspace diagnostics
+			if (file === "*") {
+				// `*` => run workspace diagnostics across all configured servers
 				const result = await runWorkspaceDiagnostics(this.session.cwd, signal);
 				return {
 					content: [
@@ -988,6 +1158,18 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 				};
 			}
 
+			if (!file) {
+				return {
+					content: [
+						{
+							type: "text",
+							text: "Error: file parameter required. Use `*` for workspace-wide diagnostics or a path/glob for specific files.",
+						},
+					],
+					details: { action, success: false, request: params },
+				};
+			}
+
 			let targets: string[];
 			let truncatedGlobTargets = false;
 			if (hasGlobPattern(file)) {
@@ -1044,13 +1226,13 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 						const client = await getOrCreateClient(serverConfig, this.session.cwd);
 						const minVersion = client.diagnosticsVersion;
 						await refreshFile(client, resolved, signal);
-						const diagnostics = await waitForDiagnostics(
-							client,
-							uri,
-							diagnosticsWaitTimeoutMs,
+						const expectedDocumentVersion = client.openFiles.get(uri)?.version;
+						const diagnostics = await waitForDiagnostics(client, uri, {
+							timeoutMs: diagnosticsWaitTimeoutMs,
 							signal,
 							minVersion,
-						);
+							expectedDocumentVersion,
+						});
 						allDiagnostics.push(...diagnostics);
 					} catch (err) {
 						if (err instanceof ToolAbortError || signal?.aborted) {
@@ -1106,17 +1288,24 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 			};
 		}
 
-		const requiresFile = !file && action !== "symbols" && action !== "reload";
+		// `*` means workspace scope for symbols/reload; other actions need a concrete file.
+		const isWorkspace = file === "*";
+		const requiresFile = !file && action !== "reload";
 
 		if (requiresFile) {
 			return {
-				content: [{ type: "text", text: "Error: file parameter required for this action" }],
+				content: [
+					{
+						type: "text",
+						text: "Error: file parameter required. Use `*` for workspace scope where supported.",
+					},
+				],
 				details: { action, success: false },
 			};
 		}
 
-		const resolvedFile = file ? resolveToCwd(file, this.session.cwd) : null;
-		if (action === "symbols" && !resolvedFile) {
+		const resolvedFile = file && !isWorkspace ? resolveToCwd(file, this.session.cwd) : null;
+		if (action === "symbols" && (isWorkspace || !resolvedFile)) {
 			const normalizedQuery = query?.trim();
 			if (!normalizedQuery) {
 				return {
@@ -1188,7 +1377,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 			};
 		}
 
-		if (action === "reload" && !resolvedFile) {
+		if (action === "reload" && (isWorkspace || !resolvedFile)) {
 			const servers = getLspServers(config);
 			if (servers.length === 0) {
 				return {
@@ -1372,7 +1561,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 				}
 
 				case "code_actions": {
-					const diagnostics = client.diagnostics.get(uri) ?? [];
+					const diagnostics = client.diagnostics.get(uri)?.diagnostics ?? [];
 					const context: CodeActionContext = {
 						diagnostics,
 						only: !apply && query ? [query] : undefined,

package/src/lsp/lspmux.ts

@@ -1,6 +1,6 @@
 import * as os from "node:os";
 import * as path from "node:path";
-import { $env, logger } from "@oh-my-pi/pi-utils";
+import { $env, $which, logger } from "@oh-my-pi/pi-utils";
 import { TOML } from "bun";
 
 /**
@@ -141,7 +141,7 @@ export async function detectLspmux(): Promise<LspmuxState> {
 		return cachedState;
 	}
 
-	const binaryPath = Bun.which("lspmux");
+	const binaryPath = $which("lspmux");
 	if (!binaryPath) {
 		cachedState = { available: false, running: false, binaryPath: null, config: null };
 		cacheTimestamp = now;

package/src/lsp/startup-events.ts

@@ -0,0 +1,13 @@
+import type { LspStartupServerInfo } from "./index";
+
+export const LSP_STARTUP_EVENT_CHANNEL = "lsp:startup";
+
+export type LspStartupEvent =
+	| {
+			type: "completed";
+			servers: Array<LspStartupServerInfo & { status: "ready" | "error" }>;
+	  }
+	| {
+			type: "failed";
+			error: string;
+	  };

package/src/lsp/types.ts

@@ -93,6 +93,17 @@ export interface Diagnostic {
 	data?: unknown;
 }
 
+export interface PublishedDiagnostics {
+	diagnostics: Diagnostic[];
+	version: number | null;
+}
+
+export interface PublishDiagnosticsParams {
+	uri: string;
+	diagnostics: Diagnostic[];
+	version?: number | null;
+}
+
 // =============================================================================
 // Text Edits
 // =============================================================================
@@ -392,7 +403,7 @@ export interface LspClient {
 	config: ServerConfig;
 	proc: ptree.ChildProcess<"pipe">;
 	requestId: number;
-	diagnostics: Map<string, Diagnostic[]>;
+	diagnostics: Map<string, PublishedDiagnostics>;
 	diagnosticsVersion: number;
 	openFiles: Map<string, OpenFile>;
 	pendingRequests: Map<number, PendingRequest>;

package/src/lsp/utils.ts

@@ -52,6 +52,7 @@ const LANGUAGE_MAP: Record<string, string> = {
 	".zsh": "shellscript",
 	".fish": "fish",
 	".pl": "perl",
+	".pm": "perl",
 	".php": "php",
 
 	// JVM languages
@@ -76,6 +77,7 @@ const LANGUAGE_MAP: Record<string, string> = {
 	".less": "less",
 	".vue": "vue",
 	".svelte": "svelte",
+	".astro": "astro",
 
 	// Data formats
 	".json": "json",
@@ -129,6 +131,8 @@ const LANGUAGE_MAP: Record<string, string> = {
 	".psm1": "powershell",
 	".bat": "bat",
 	".cmd": "bat",
+	".tla": "tlaplus",
+	".tlaplus": "tlaplus",
 };
 
 /**
@@ -140,12 +144,15 @@ export function detectLanguageId(filePath: string): string {
 	const basename = path.basename(filePath).toLowerCase();
 
 	// Handle special filenames
-	if (basename === "dockerfile" || basename.startsWith("dockerfile.")) {
+	if (basename === "dockerfile" || basename.startsWith("dockerfile.") || basename === "containerfile") {
 		return "dockerfile";
 	}
 	if (basename === "makefile" || basename === "gnumakefile") {
 		return "makefile";
 	}
+	if (basename === "justfile") {
+		return "just";
+	}
 	if (basename === "cmakelists.txt" || ext === ".cmake") {
 		return "cmake";
 	}