lazycodex-ai 5.1.48 → 5.1.51

package/packages/lsp-core/src/lsp/workspace-mutation-controller.ts

@@ -0,0 +1,182 @@
+import type { WorkspaceEdit } from "./types.js";
+import { workspaceApplyEditConcurrentFailureReason } from "./workspace-apply-edit-failure.js";
+import { commitWorkspaceEditPlan } from "./workspace-edit-commit.js";
+import { fingerprintWorkspaceEdit, planWorkspaceEdit } from "./workspace-edit-plan.js";
+import type {
+	ApplyResult,
+	LspRenameResult,
+	WorkspaceEditCommitIo,
+} from "./workspace-edit-types.js";
+import { WorkspaceDocumentState } from "./workspace-document-state.js";
+
+export interface WorkspaceApplyEditResponse {
+	readonly applied: boolean;
+	readonly failureReason?: string;
+	readonly failedChange?: number;
+}
+
+export interface WorkspaceMutationLease {
+	readonly id: number;
+}
+
+interface ServerApplyRecord {
+	readonly fingerprint: string | null;
+	readonly result: ApplyResult;
+}
+
+interface ActiveLease extends WorkspaceMutationLease {
+	readonly signal?: AbortSignal;
+	phase: "idle" | "applying" | "settled" | "sealed";
+	serverApply?: ServerApplyRecord;
+	applyCompletion?: Promise<void>;
+	resolveApply?: () => void;
+}
+
+export type AcquireMutationLeaseResult =
+	| { readonly success: true; readonly lease: WorkspaceMutationLease }
+	| { readonly success: false; readonly result: ApplyResult };
+
+function failure(message: string, failedChange?: number, base?: ApplyResult): ApplyResult {
+	return {
+		success: false,
+		filesModified: base?.filesModified ?? [],
+		totalEdits: base?.totalEdits ?? 0,
+		errors: [message],
+		...(failedChange === undefined ? {} : { failedChange }),
+		...(base?.lateAbort ? { lateAbort: true } : {}),
+	};
+}
+
+function responseFor(result: ApplyResult): WorkspaceApplyEditResponse {
+	if (result.success) return { applied: true };
+	return {
+		applied: false,
+		failureReason: result.errors[0] ?? "workspace edit failed",
+		...(result.failedChange === undefined ? {} : { failedChange: result.failedChange }),
+	};
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export class WorkspaceMutationController {
+	private activeLease: ActiveLease | null = null;
+	private nextLeaseId = 1;
+	private io: Partial<WorkspaceEditCommitIo> | undefined;
+
+	constructor(
+		private readonly workspaceRoot: string,
+		private readonly documents: WorkspaceDocumentState,
+	) {}
+
+	setIo(io: Partial<WorkspaceEditCommitIo>): void {
+		this.io = io;
+	}
+
+	acquire(signal?: AbortSignal): AcquireMutationLeaseResult {
+		if (this.activeLease) return { success: false, result: failure("workspace mutation is already in progress") };
+		if (signal?.aborted) return { success: false, result: failure("cancelled before mutating request") };
+		const lease: ActiveLease = {
+			id: this.nextLeaseId,
+			phase: "idle",
+			...(signal === undefined ? {} : { signal }),
+		};
+		this.nextLeaseId += 1;
+		this.activeLease = lease;
+		return { success: true, lease };
+	}
+
+	release(lease: WorkspaceMutationLease): void {
+		if (this.activeLease?.id !== lease.id) return;
+		this.activeLease.phase = "sealed";
+		this.activeLease = null;
+	}
+
+	isBeforeCommit(lease: WorkspaceMutationLease): boolean {
+		return this.activeLease?.id === lease.id && this.activeLease.phase === "idle";
+	}
+
+	async handleApplyEdit(params: unknown): Promise<WorkspaceApplyEditResponse> {
+		const lease = this.activeLease;
+		if (!lease) return { applied: false, failureReason: "workspace/applyEdit requires an active workspace mutation" };
+		if (lease.phase !== "idle") {
+			return {
+				applied: false,
+				failureReason: workspaceApplyEditConcurrentFailureReason(lease.phase === "applying" ? "applying" : "settled"),
+			};
+		}
+
+		lease.phase = "applying";
+		lease.applyCompletion = new Promise<void>((resolve) => {
+			lease.resolveApply = resolve;
+		});
+		const edit = isRecord(params) ? params["edit"] : undefined;
+		const record =
+			edit === undefined
+				? { fingerprint: null, result: failure("workspace/applyEdit params.edit is required", 0) }
+				: await this.applyEdit(edit, lease);
+		lease.serverApply = record;
+		lease.phase = "settled";
+		lease.resolveApply?.();
+		return responseFor(record.result);
+	}
+
+	async reconcileRename(
+		leaseToken: WorkspaceMutationLease,
+		edit: WorkspaceEdit | null,
+	): Promise<LspRenameResult> {
+		const lease = this.requireActiveLease(leaseToken);
+		if (!lease) return { edit, apply: failure("workspace mutation lease ended before rename reconciliation") };
+		if (lease.phase === "applying") await lease.applyCompletion;
+		if (lease.serverApply) return this.reconcileServerApply(lease.serverApply, edit);
+		lease.phase = "sealed";
+		if (!edit) return { edit, apply: failure("No edit provided") };
+		const applied = await this.applyEdit(edit, lease);
+		return { edit, apply: applied.result };
+	}
+
+	private reconcileServerApply(record: ServerApplyRecord, edit: WorkspaceEdit | null): LspRenameResult {
+		if (!edit) return { edit, apply: record.result };
+		const fingerprint = fingerprintWorkspaceEdit(edit, this.workspaceRoot);
+		if (fingerprint.success && record.fingerprint !== null && fingerprint.fingerprint === record.fingerprint) {
+			return { edit, apply: record.result };
+		}
+		return {
+			edit,
+			apply: failure("rename result conflicts with server-applied workspace edit", 0, record.result),
+		};
+	}
+
+	private async applyEdit(edit: unknown, lease: ActiveLease): Promise<ServerApplyRecord> {
+		const planned = planWorkspaceEdit(edit, this.workspaceRoot);
+		if (!planned.success) return { fingerprint: null, result: planned.result };
+		const versionFailure = this.documents.validateVersions(planned.plan.operations);
+		if (versionFailure) {
+			return {
+				fingerprint: planned.plan.fingerprint,
+				result: failure(versionFailure.message, versionFailure.changeIndex),
+			};
+		}
+
+		const commit = commitWorkspaceEditPlan(planned.plan, {
+			...(lease.signal === undefined ? {} : { signal: lease.signal }),
+			...(this.io === undefined ? {} : { io: this.io }),
+		});
+		let result = commit.result;
+		if (commit.delta.operations.length > 0) {
+			try {
+				await this.documents.synchronize(commit.delta);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				result = failure(`document synchronization failed after filesystem commit: ${message}`, undefined, result);
+			}
+		}
+		if (lease.signal?.aborted && !result.lateAbort) result = { ...result, lateAbort: true };
+		return { fingerprint: planned.plan.fingerprint, result };
+	}
+
+	private requireActiveLease(lease: WorkspaceMutationLease): ActiveLease | null {
+		return this.activeLease?.id === lease.id ? this.activeLease : null;
+	}
+}

package/packages/lsp-core/src/mcp-protocol-pin.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "bun:test";
+import { Readable, Writable } from "node:stream";
+import { handleLspMcpRequest, runMcpStdioServer } from "./mcp";
+
+describe("lsp MCP protocol pins", () => {
+  for (const [requested, expected] of [
+    ["2025-06-18", "2025-06-18"],
+    ["2025-03-26", "2025-03-26"],
+    ["2024-11-05", "2024-11-05"],
+    ["2026-07-28", "2025-06-18"],
+    ["2025-11-25", "2025-06-18"],
+    ["unknown", "2025-06-18"],
+    ["", "2025-06-18"],
+    [null, "2025-06-18"],
+    [42, "2025-06-18"],
+    [undefined, "2025-06-18"],
+  ] as const) {
+    it(`negotiates ${String(requested)} as ${expected} over stdio`, async () => {
+      const out: string[] = [];
+      await runMcpStdioServer(Readable.from([`${JSON.stringify({
+        jsonrpc: "2.0", id: 7, method: "initialize",
+        params: { protocolVersion: requested },
+      })}\n`]), collectingWritable(out));
+      expect(JSON.parse(out.join(""))).toEqual({
+        jsonrpc: "2.0", id: 7,
+        result: {
+          capabilities: { tools: { listChanged: false } },
+          serverInfo: { name: "lsp", version: "0.1.0" },
+          protocolVersion: expected,
+        },
+      });
+    });
+  }
+
+  it("#given initialize request #when handled #then exact server info and capabilities stay stable", async () => {
+    const response = await handleLspMcpRequest({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "initialize",
+      params: { protocolVersion: "2024-11-05", capabilities: {}, clientInfo: { name: "todo-23", version: "0.0.0" } },
+    });
+
+    expect(response).toEqual({
+      jsonrpc: "2.0",
+      id: 1,
+      result: {
+        capabilities: { tools: { listChanged: false } },
+        serverInfo: { name: "lsp", version: "0.1.0" },
+        protocolVersion: "2024-11-05",
+      },
+    });
+  });
+
+  it("#given malformed stdio line #when read #then parse error envelope includes parser data", async () => {
+    const out: string[] = [];
+
+    await runMcpStdioServer(Readable.from(["garbage\n"]), collectingWritable(out));
+
+    const response = JSON.parse(out.join(""));
+    if (!isProtocolErrorResponse(response)) {
+      throw new TypeError(`Expected protocol error response: ${out.join("")}`);
+    }
+
+    expect(response).toEqual({
+      jsonrpc: "2.0",
+      id: null,
+      error: {
+        code: -32700,
+        message: "Parse error",
+        data: response.error.data,
+      },
+    });
+    expect(typeof response.error.data).toBe("string");
+    expect(response.error.data).toContain("garbage");
+  });
+});
+
+function collectingWritable(chunks: string[]): Writable {
+  return new Writable({
+    write(chunk, _encoding, callback): void {
+      chunks.push(chunk.toString());
+      callback();
+    },
+  });
+}
+
+function isProtocolErrorResponse(value: unknown): value is {
+  readonly jsonrpc: string;
+  readonly id: null;
+  readonly error: { readonly code: number; readonly message: string; readonly data?: unknown };
+} {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const record = value;
+  if (!("error" in record)) return false;
+  const { error } = record;
+  return typeof error === "object" && error !== null && !Array.isArray(error);
+}

package/packages/lsp-core/src/mcp.ts

@@ -0,0 +1,122 @@
+import type { Readable, Writable } from "node:stream";
+import {
+	errorResponse,
+	isPlainRecord,
+	jsonRpcId,
+	runJsonRpcStdioServer,
+	successResponse,
+	type JsonRpcError,
+	type JsonRpcId,
+	type JsonRpcResponse,
+	type JsonRpcResult,
+	type McpToolDescriptor,
+	type ParentWatchdogConfig,
+} from "@oh-my-opencode/mcp-stdio-core";
+import { coerceToolArguments, executeLspTool, LSP_MCP_TOOLS } from "./tools.js";
+import { createStandaloneMcpRequestContext, runWithRequestContext } from "./request-context.js";
+
+export type { JsonRpcError, JsonRpcId, JsonRpcResponse, JsonRpcResult, McpToolDescriptor };
+
+const SERVER_NAME = "lsp";
+const SERVER_VERSION = "0.1.0";
+const PROTOCOL_VERSIONS: readonly string[] = ["2025-06-18", "2025-03-26", "2024-11-05"];
+
+export interface HandleLspMcpRequestOptions {
+	readonly signal?: AbortSignal;
+}
+
+export interface LspMcpStdioServerOptions {
+	// Test seam: production callers leave this unset so the watchdog uses its
+	// defaults (parentPid = process.ppid, 30s poll).
+	readonly parentWatchdog?: ParentWatchdogConfig;
+}
+
+export async function handleLspMcpRequest(
+	input: unknown,
+	options: HandleLspMcpRequestOptions = {},
+): Promise<JsonRpcResponse | undefined> {
+	if (!isPlainRecord(input)) {
+		return errorResponse(null, -32600, "Invalid Request");
+	}
+
+	const id = jsonRpcId(input["id"]);
+	const method = input["method"];
+	if (method === "notifications/initialized") return undefined;
+	if (method === "ping") return successResponse(id, {});
+	if (method === "initialize") {
+		const protocolVersion = requestedProtocolVersion(input["params"]);
+		return successResponse(id, {
+			capabilities: { tools: { listChanged: false } },
+			serverInfo: { name: SERVER_NAME, version: SERVER_VERSION },
+			protocolVersion,
+		});
+	}
+
+	if (method === "tools/list") {
+		return successResponse(id, { tools: LSP_MCP_TOOLS.map(describeTool) });
+	}
+
+	if (method === "tools/call") {
+		return handleToolCall(id, input["params"], options.signal);
+	}
+
+	return errorResponse(id, -32601, `Method not found: ${String(method)}`);
+}
+
+export async function runMcpStdioServer(
+	input: Readable = process.stdin,
+	output: Writable = process.stdout,
+	options: LspMcpStdioServerOptions = {},
+): Promise<void> {
+	const requestContext = createStandaloneMcpRequestContext();
+	await runJsonRpcStdioServer({
+		input,
+		output,
+		// Idle stays disabled: hosts of this CLI (legacy opencode configs and
+		// standalone lsp-tools-mcp users) have no evidenced respawn for an exited
+		// stdio server; opencode in particular marks it failed without retry.
+		idleTimeoutMs: 0,
+		parentWatchdog: options.parentWatchdog ?? {},
+		handler: (request) => runWithRequestContext(requestContext, () => handleLspMcpRequest(request)),
+		handlerOptions: undefined,
+	});
+}
+
+async function handleToolCall(id: JsonRpcId, params: unknown, signal?: AbortSignal): Promise<JsonRpcResponse> {
+	if (!isPlainRecord(params) || typeof params["name"] !== "string") {
+		return errorResponse(id, -32602, "tools/call requires params.name");
+	}
+
+	try {
+		const result = await executeLspTool(params["name"], coerceToolArguments(params["arguments"]), signal);
+		return successResponse(id, {
+			content: result.content,
+			isError: result.isError ?? false,
+			details: result.details,
+		});
+	} catch (error) {
+		if (!(error instanceof Error)) {
+			throw error;
+		}
+		return successResponse(id, {
+			content: [{ type: "text", text: error.message }],
+			isError: true,
+		});
+	}
+}
+
+function describeTool(tool: (typeof LSP_MCP_TOOLS)[number]): McpToolDescriptor {
+	return {
+		name: tool.name,
+		title: tool.title,
+		description: tool.description,
+		inputSchema: tool.inputSchema,
+	};
+}
+
+function requestedProtocolVersion(params: unknown): string {
+	const requested = isPlainRecord(params) ? params["protocolVersion"] : undefined;
+	return typeof requested === "string" && PROTOCOL_VERSIONS.includes(requested)
+		? requested
+		: "2025-06-18";
+}

package/packages/lsp-core/src/missing-dependency-result.test.ts

@@ -0,0 +1,135 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "bun:test";
+
+import { LspServerLookupError } from "./lsp/errors.js";
+import { missingDependencyResult } from "./missing-dependency-result.js";
+import { parseLspRequestContext, runWithRequestContext } from "./request-context.js";
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+function tempRoot(): string {
+	const root = mkdtempSync(join(homedir(), "lsp-missing-dep-"));
+	tempDirectories.push(root);
+	return root;
+}
+
+describe("missingDependencyResult", () => {
+	it("#given not configured lookup #when converted #then includes structured availability and typed config paths", () => {
+		const root = tempRoot();
+		const projectConfigPath = join(root, ".codex", "lsp-client.json");
+		const userConfigPath = join(homedir(), ".codex", "lsp-client.json");
+		const installDecisionsPath = join(homedir(), ".codex", "lsp-install-decisions.json");
+		const context = parseLspRequestContext({
+			cwd: root,
+			projectConfigPaths: [projectConfigPath],
+			userConfigPath,
+			installDecisionsPath,
+			capabilities: { installDecisionTool: false },
+		});
+
+		const result = runWithRequestContext(context, () =>
+			missingDependencyResult(
+				new LspServerLookupError("No LSP server configured for extension: .foo", {
+					status: "not_configured",
+					extension: ".foo",
+					availableServers: ["typescript"],
+				}),
+				{ filePath: "src/file.foo" },
+			),
+		);
+
+		expect(result?.details).toEqual({
+			filePath: "src/file.foo",
+			error: "No LSP server configured for extension: .foo",
+			errorKind: "missing_dependency",
+			availability: {
+				kind: "not_configured",
+				extension: ".foo",
+				availableServers: ["typescript"],
+				projectConfigPaths: [projectConfigPath],
+				userConfigPath,
+				installDecisionTool: false,
+			},
+		});
+	});
+
+	it("#given not installed lookup #when converted #then includes install decision availability", () => {
+		const root = tempRoot();
+		const installDecisionsPath = join(root, "lsp-install-decisions.json");
+		const context = parseLspRequestContext({
+			cwd: root,
+			projectConfigPaths: [join(root, ".codex", "lsp-client.json")],
+			userConfigPath: join(homedir(), ".codex", "lsp-client.json"),
+			installDecisionsPath,
+			capabilities: { installDecisionTool: true },
+		});
+
+		const result = runWithRequestContext(context, () =>
+			missingDependencyResult(
+				new LspServerLookupError("LSP server 'typescript' for .ts is NOT INSTALLED.", {
+					status: "not_installed",
+					server: {
+						id: "typescript",
+						command: ["typescript-language-server", "--stdio"],
+						extensions: [".ts"],
+					},
+					installHint: "npm install -g typescript-language-server typescript",
+				}),
+				{ filePath: "src/file.ts" },
+			),
+		);
+
+		expect(result?.details).toEqual({
+			filePath: "src/file.ts",
+			error: "LSP server 'typescript' for .ts is NOT INSTALLED.",
+			errorKind: "missing_dependency",
+			availability: {
+				kind: "not_installed",
+				serverId: "typescript",
+				command: ["typescript-language-server", "--stdio"],
+				extensions: [".ts"],
+				installHint: "npm install -g typescript-language-server typescript",
+				installDecisionTool: true,
+				installDecisionsPath,
+				decision: null,
+			},
+		});
+	});
+
+	it("#given a recorded decision #when a not installed lookup is converted #then availability carries it", () => {
+		const root = tempRoot();
+		const installDecisionsPath = join(root, "lsp-install-decisions.json");
+		writeFileSync(
+			installDecisionsPath,
+			JSON.stringify({ biome: { decision: "declined", decidedAt: "2026-09-29T00:00:00.000Z" } }),
+		);
+		const context = parseLspRequestContext({
+			cwd: root,
+			projectConfigPaths: [join(root, ".codex", "lsp-client.json")],
+			userConfigPath: join(root, "lsp-client.json"),
+			installDecisionsPath,
+			capabilities: { installDecisionTool: false },
+		});
+
+		const result = runWithRequestContext(context, () =>
+			missingDependencyResult(
+				new LspServerLookupError("LSP server 'biome' is NOT INSTALLED.", {
+					status: "not_installed",
+					server: { id: "biome", command: ["biome", "lsp-proxy"], extensions: [".json"] },
+					installHint: "npm install -g @biomejs/biome",
+				}),
+				{ filePath: "a.json" },
+			),
+		);
+
+		expect(result?.details).toMatchObject({ availability: { kind: "not_installed", decision: "declined" } });
+	});
+});

package/packages/lsp-core/src/missing-dependency-result.ts

@@ -0,0 +1,79 @@
+import { LspServerLookupError } from "./lsp/errors.js";
+import { type InstallDecision, loadInstallDecision } from "./lsp/server-install-state.js";
+import { handleMissingDependencyError } from "./lsp/startup-failure.js";
+import { lspRequestContext } from "./request-context.js";
+import type { ToolExecutionResult } from "./tools.js";
+
+export type MissingDependencyAvailability =
+	| {
+			readonly kind: "not_configured";
+			readonly extension: string;
+			readonly availableServers: readonly string[];
+			readonly projectConfigPaths: readonly string[];
+			readonly userConfigPath: string;
+			readonly installDecisionTool: boolean;
+	  }
+	| {
+			readonly kind: "not_installed";
+			readonly serverId: string;
+			readonly command: readonly string[];
+			readonly extensions: readonly string[];
+			readonly installHint: string;
+			readonly installDecisionTool: boolean;
+			readonly installDecisionsPath: string;
+			readonly decision: InstallDecision | null;
+	  };
+
+export function missingDependencyResult<TDetails extends object>(
+	error: unknown,
+	details: TDetails,
+): ToolExecutionResult | null {
+	const message = handleMissingDependencyError(error);
+	if (!message) return null;
+
+	return {
+		content: [{ type: "text", text: message }],
+		details: {
+			...details,
+			error: message,
+			errorKind: "missing_dependency",
+			...availabilityDetails(error),
+		},
+	};
+}
+
+function availabilityDetails(error: unknown): { readonly availability: MissingDependencyAvailability } | object {
+	const availability = missingDependencyAvailability(error);
+	return availability === null ? {} : { availability };
+}
+
+function missingDependencyAvailability(error: unknown): MissingDependencyAvailability | null {
+	if (!(error instanceof LspServerLookupError) || error.lookup === undefined) return null;
+	const context = lspRequestContext();
+	switch (error.lookup.status) {
+		case "not_configured":
+			return {
+				kind: "not_configured",
+				extension: error.lookup.extension,
+				availableServers: [...error.lookup.availableServers],
+				projectConfigPaths: [...context.projectConfigPaths],
+				userConfigPath: context.userConfigPath,
+				installDecisionTool: context.capabilities.installDecisionTool,
+			};
+		case "not_installed":
+			return {
+				kind: "not_installed",
+				serverId: error.lookup.server.id,
+				command: [...error.lookup.server.command],
+				extensions: [...error.lookup.server.extensions],
+				installHint: error.lookup.installHint,
+				installDecisionTool: context.capabilities.installDecisionTool,
+				installDecisionsPath: context.installDecisionsPath,
+				decision: loadInstallDecision(error.lookup.server.id)?.decision ?? null,
+			};
+		default: {
+			const exhaustive: never = error.lookup;
+			return exhaustive;
+		}
+	}
+}

package/packages/lsp-core/src/post-edit/file-location.ts

@@ -0,0 +1,55 @@
+import { homedir, tmpdir } from "node:os";
+import { dirname, resolve } from "node:path";
+
+import { nearestMarkedAncestor } from "../lsp/outside-context-workspace.js";
+import { canonicalizeExistingOrNearestAncestor, isPathInside } from "../request-context.js";
+
+export type PostEditFileLocation = "project" | "outside_project" | "agent_config" | "temp";
+
+export interface PostEditFileLocationOptions {
+	readonly cwd: string;
+	readonly agentDirs: readonly string[];
+	/** Temp roots; defaults to the canonical OS temp dir (plus `/tmp` off Windows). */
+	readonly tempDirs?: readonly string[];
+	/** Home dirs that never count as a project root themselves; defaults to the OS home dir. */
+	readonly homeDirs?: readonly string[];
+}
+
+/**
+ * Classifies an edited file for install guidance.
+ *
+ * A project root is the nearest ancestor carrying one of lsp-core's `WORKSPACE_MARKERS` (the marker set the
+ * out-of-cwd workspace resolver uses). Inside a temp dir, only a marked root strictly below the temp root
+ * counts, so a stray `package.json` left in the temp root does not turn every scratch file into a project.
+ * The home dir is never a project root either: a dotfiles `.git` or stray `~/package.json` there does not make
+ * every home-level file a project, while a marked project below home still is one.
+ * Paths are canonicalized first because macOS `/tmp` and `/var` are symlinks.
+ */
+export function classifyPostEditFileLocation(
+	filePath: string,
+	options: PostEditFileLocationOptions,
+): PostEditFileLocation {
+	const file = canonicalizeExistingOrNearestAncestor(resolve(options.cwd, filePath));
+	if (canonicalDirectories(options.agentDirs).some((directory) => isPathInside(directory, file))) {
+		return "agent_config";
+	}
+
+	const projectRoot = nearestMarkedAncestor(dirname(file));
+	const tempRoot = canonicalDirectories(options.tempDirs ?? defaultTempDirectories()).find((directory) =>
+		isPathInside(directory, file),
+	);
+	if (tempRoot !== undefined) {
+		const ownProject = projectRoot !== undefined && projectRoot !== tempRoot && isPathInside(tempRoot, projectRoot);
+		return ownProject ? "project" : "temp";
+	}
+	if (projectRoot === undefined) return "outside_project";
+	return canonicalDirectories(options.homeDirs ?? [homedir()]).includes(projectRoot) ? "outside_project" : "project";
+}
+
+function defaultTempDirectories(): readonly string[] {
+	return process.platform === "win32" ? [tmpdir()] : [tmpdir(), "/tmp"];
+}
+
+function canonicalDirectories(directories: readonly string[]): readonly string[] {
+	return directories.map((directory) => canonicalizeExistingOrNearestAncestor(directory));
+}

package/packages/lsp-core/src/post-edit/index.ts

@@ -0,0 +1,3 @@
+export * from "./file-location.js";
+export * from "./not-installed-guidance.js";
+export * from "./orchestration.js";