@effect/tsgo 0.18.1 → 0.20.0

package/README.md

@@ -101,6 +101,7 @@ Some diagnostics are off by default or have a default severity of suggestion, bu
     <tr><td><code>effectMapFlatten</code></td><td>💡</td><td></td><td>Suggests using Effect.flatMap instead of Effect.map followed by Effect.flatten in piping flows</td><td>✓</td><td>✓</td></tr>
     <tr><td><code>effectMapVoid</code></td><td>💡</td><td>🔧</td><td>Suggests using Effect.asVoid instead of Effect.map(() =&gt; void 0), Effect.map(() =&gt; undefined), or Effect.map(() =&gt; {})</td><td>✓</td><td>✓</td></tr>
     <tr><td><code>effectSucceedWithVoid</code></td><td>💡</td><td>🔧</td><td>Suggests using Effect.void instead of Effect.succeed(undefined) or Effect.succeed(void 0)</td><td>✓</td><td>✓</td></tr>
+    <tr><td><code>flatMapToMap</code></td><td>💡</td><td>🔧</td><td>Suggests using Effect.map instead of Effect.flatMap when the callback only wraps its result with Effect.succeed</td><td>✓</td><td>✓</td></tr>
     <tr><td><code>missedPipeableOpportunity</code></td><td>➖</td><td>🔧</td><td>Suggests using .pipe() for nested function calls</td><td>✓</td><td>✓</td></tr>
     <tr><td><code>missingEffectServiceDependency</code></td><td>➖</td><td></td><td>Checks that Effect.Service dependencies satisfy all required layer inputs</td><td>✓</td><td></td></tr>
     <tr><td><code>multipleCatchTag</code></td><td>💡</td><td></td><td>Suggests collapsing consecutive Effect.catchTag transformations into a single Effect.catchTags call when semantics stay equivalent</td><td></td><td>✓</td></tr>

package/dist/effect-tsgo.js

@@ -4158,6 +4158,73 @@ const liftThrowable = (f) => (...a) => {
 	}
 };
 /**
+* Extracts the value from a `Some`, or throws a custom error for `None`.
+*
+* **When to use**
+*
+* Use when you need fail-fast unwrapping of an `Option` for unexpected absence
+* and want to provide a descriptive debugging error.
+*
+* **Details**
+*
+* - `Some` → returns the inner value
+* - `None` → throws the value returned by `onNone()`
+*
+* **Example** (Throwing a custom error)
+*
+* ```ts
+* import { Option } from "effect"
+*
+* console.log(Option.getOrThrowWith(Option.some(1), () => new Error("missing")))
+* // Output: 1
+*
+* Option.getOrThrowWith(Option.none(), () => new Error("missing"))
+* // throws Error: missing
+* ```
+*
+* @see {@link getOrThrow} for a version with a default error
+* @see {@link getOrElse} for a non-throwing alternative
+*
+* @category converting
+* @since 2.0.0
+*/
+const getOrThrowWith = /* @__PURE__ */ dual(2, (self, onNone) => {
+	if (isSome(self)) return self.value;
+	throw onNone();
+});
+/**
+* Extracts the value from a `Some`, or throws a default `Error` for `None`.
+*
+* **When to use**
+*
+* Use when you need quick fail-fast unwrapping of an `Option` and a generic
+* error is acceptable.
+*
+* **Details**
+*
+* - `Some` → returns the inner value
+* - `None` → throws `new Error("getOrThrow called on a None")`
+*
+* **Example** (Throwing a default error)
+*
+* ```ts
+* import { Option } from "effect"
+*
+* console.log(Option.getOrThrow(Option.some(1)))
+* // Output: 1
+*
+* Option.getOrThrow(Option.none())
+* // throws Error: getOrThrow called on a None
+* ```
+*
+* @see {@link getOrThrowWith} for a custom error
+* @see {@link getOrElse} for a non-throwing alternative
+*
+* @category converting
+* @since 2.0.0
+*/
+const getOrThrow = /* @__PURE__ */ getOrThrowWith(() => /* @__PURE__ */ new Error("getOrThrow called on a None"));
+/**
 * Transforms the value inside a `Some` using the provided function, leaving
 * `None` unchanged.
 *
@@ -53904,6 +53971,49 @@ const choice$2 = (choices) => {
 	return Object.assign(primitive, { choiceKeys: choices.map(([key]) => key) });
 };
 /**
+* Creates a primitive that validates and resolves file system paths.
+*
+* **Example** (Parsing file system paths)
+*
+* ```ts
+* import { Effect } from "effect"
+* import { Primitive } from "effect/unstable/cli"
+*
+* const program = Effect.gen(function*() {
+*   // Parse a file path that must exist
+*   const filePrimitive = Primitive.path("file", true)
+*   const filePath = yield* filePrimitive.parse("./package.json")
+*   console.log(filePath) // Absolute path to package.json
+*
+*   // Parse a directory path
+*   const dirPrimitive = Primitive.path("directory", false)
+*   const dirPath = yield* dirPrimitive.parse("./src")
+*   console.log(dirPath) // Absolute path to src directory
+*
+*   // Parse any path type
+*   const anyPrimitive = Primitive.path("either", false)
+*   const anyPath = yield* anyPrimitive.parse("./some/path")
+*   console.log(anyPath) // Absolute path
+* })
+* ```
+*
+* @category constructors
+* @since 4.0.0
+*/
+const path$1 = (pathType, mustExist) => makePrimitive("Path", fnUntraced(function* (value) {
+	const fs = yield* FileSystem;
+	const path = yield* Path;
+	const absolutePath = path.isAbsolute(value) ? value : path.resolve(value);
+	const exists = yield* mapError(fs.exists(absolutePath), (error) => `Failed to check path existence: ${error.message}`);
+	if (mustExist === true && !exists) return yield* fail(`Path does not exist: ${absolutePath}`);
+	if (exists && pathType !== "either") {
+		const stat = yield* mapError(fs.stat(absolutePath), (error) => `Failed to stat path: ${error.message}`);
+		if (pathType === "file" && stat.type !== "File") return yield* fail(`Path is not a file: ${absolutePath}`);
+		if (pathType === "directory" && stat.type !== "Directory") return yield* fail(`Path is not a directory: ${absolutePath}`);
+	}
+	return absolutePath;
+}));
+/**
 * Creates a sentinel primitive that always fails to parse a value.
 *
 * **When to use**
@@ -54207,7 +54317,7 @@ const custom = (initialState, ...args) => {
 * @category constructors
 * @since 4.0.0
 */
-const file = (options = {}) => {
+const file$2 = (options = {}) => {
 	const opts = {
 		type: options.type ?? "file",
 		message: options.message ?? `Choose a file`,
@@ -55124,6 +55234,71 @@ const choice$1 = (kind, name, choices) => {
 	return choiceWithValue$1(kind, name, choices.map((value) => [value, value]));
 };
 /**
+* Creates a path parameter that accepts file or directory paths.
+*
+* **Example** (Creating path parameters)
+*
+* ```ts
+* import { Param } from "effect/unstable/cli"
+*
+* // @internal - this module is not exported publicly
+*
+* // Basic path parameter
+* const outputPath = Param.path(Param.flagKind, "output")
+*
+* // Path that must exist
+* const inputPath = Param.path(Param.flagKind, "input", { mustExist: true })
+*
+* // File-only path
+* const configFile = Param.path(Param.flagKind, "config", {
+*   pathType: "file",
+*   mustExist: true,
+*   typeName: "config-file"
+* })
+* ```
+*
+* @category constructors
+* @since 4.0.0
+*/
+const path = (kind, name, options) => makeSingle({
+	name,
+	kind,
+	primitiveType: path$1(options?.pathType ?? "either", options?.mustExist),
+	typeName: options?.typeName
+});
+/**
+* Creates a file path parameter.
+*
+* **Details**
+*
+* This is a convenience function that creates a path parameter with a
+* `pathType` set to `"file"` and a default type name of `"file"`.
+*
+* **Example** (Creating file parameters)
+*
+* ```ts
+* import { Param } from "effect/unstable/cli"
+*
+* // @internal - this module is not exported publicly
+*
+* // Basic file parameter
+* const outputFile = Param.file(Param.flagKind, "output")
+*
+* // File that must exist
+* const inputFile = Param.file(Param.flagKind, "input", { mustExist: true })
+*
+* // Usage: --output result.txt --input existing-file.txt
+* ```
+*
+* @category constructors
+* @since 4.0.0
+*/
+const file$1 = (kind, name, options) => path(kind, name, {
+	pathType: "file",
+	typeName: "file",
+	mustExist: options?.mustExist
+});
+/**
 * Creates an empty sentinel parameter that always fails to parse.
 *
 * **When to use**
@@ -55683,6 +55858,27 @@ const choiceWithValue = (name, choices) => choiceWithValue$1(flagKind, name, cho
 */
 const choice = (name, choices) => choice$1(flagKind, name, choices);
 /**
+* Creates a file path flag that accepts file paths with optional existence validation.
+*
+* **Example** (Creating file flags)
+*
+* ```ts
+* import { Flag } from "effect/unstable/cli"
+*
+* // Basic file flag
+* const inputFlag = Flag.file("input")
+* // Usage: --input ./data.json
+*
+* // File that must exist
+* const configFlag = Flag.file("config", { mustExist: true })
+* // Usage: --config ./config.yaml (file must exist)
+* ```
+*
+* @category constructors
+* @since 4.0.0
+*/
+const file = (name, options) => file$1(flagKind, name, options);
+/**
 * Creates an empty sentinel flag that always fails to parse.
 * This is useful for creating placeholder flags or for combinators.
 *
@@ -204655,7 +204851,7 @@ var FileReadError = class extends TaggedError("FileReadError") {
 //#endregion
 //#region package.json
 var name = "@effect/tsgo";
-var version = "0.18.1";
+var version = "0.20.0";
 
 //#endregion
 //#region src/setup/consts.ts
@@ -204663,7 +204859,6 @@ const LSP_PACKAGE_NAME = name;
 const LSP_PLUGIN_NAME = "@effect/language-service";
 const defaultTypescriptPackageNames = ["typescript", "@typescript/native"];
 const PATCH_COMMAND = "effect-tsgo patch";
-const TSCONFIG_SCHEMA_URL = "https://raw.githubusercontent.com/Effect-TS/tsgo/refs/heads/main/schema.json";
 /**
 * `typescript` package versions >= 7 ship the native Go-ported binary that this
 * tool patches. Older `typescript` releases (<= 6) are the JS compiler and must
@@ -204673,10 +204868,6 @@ const isNativeTypescriptVersion = (version) => {
 	const match = /\d+/.exec(version.trim());
 	return match !== null && Number(match[0]) >= 7;
 };
-/**
-* Resolve the VS Code TypeScript 7 tsdk folder.
-*/
-const nativeBackendTsdkPath = (packageName) => "node_modules/" + packageName;
 
 //#endregion
 //#region src/setup/assessment.ts
@@ -204766,6 +204957,7 @@ const assessTsConfig = (input) => {
 	const hasPlugins = parsed.compilerOptions?.plugins !== void 0;
 	const plugins = parsed.compilerOptions?.plugins ?? [];
 	const hasLspPlugin = plugins.some((plugin) => plugin.name === LSP_PLUGIN_NAME);
+	const currentSchemaPath = typeof parsed.$schema === "string" ? some(parsed.$schema) : none$3();
 	const currentDiagnosticSeverities = getCurrentDiagnosticSeverities(plugins);
 	return {
 		path: input.fileName,
@@ -204774,6 +204966,7 @@ const assessTsConfig = (input) => {
 		text: input.text,
 		hasPlugins,
 		hasLspPlugin,
+		currentSchemaPath,
 		currentDiagnosticSeverities
 	};
 };
@@ -205223,18 +205416,18 @@ const computeTsConfigChanges = (current, target, lspVersion) => {
 		const ctx = createTrackerContext();
 		const fileChange = tsInternal.textChanges.ChangeTracker.with(ctx, (tracker) => {
 			const schemaProperty = findPropertyInObject(rootObj, "$schema");
-			const shouldAddSchema = !schemaProperty;
-			const shouldUpdateSchema = !!schemaProperty && (!import_typescript.isStringLiteral(schemaProperty.initializer) || schemaProperty.initializer.text !== TSCONFIG_SCHEMA_URL);
+			const shouldAddSchema = isSome(target.schemaPath) && !schemaProperty;
+			const shouldUpdateSchema = isSome(target.schemaPath) && !!schemaProperty && (!import_typescript.isStringLiteral(schemaProperty.initializer) || schemaProperty.initializer.text !== target.schemaPath.value);
 			if (shouldAddSchema) descriptions.push("Add $schema to tsconfig");
 			else if (shouldUpdateSchema) descriptions.push("Update $schema in tsconfig");
 			descriptions.push(`Add compilerOptions with ${LSP_PLUGIN_NAME} plugin`);
-			const schemaPropertyAssignment = import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral("$schema"), import_typescript.factory.createStringLiteral(TSCONFIG_SCHEMA_URL));
+			const schemaPropertyAssignment = map$10(target.schemaPath, (schemaPath) => import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral("$schema"), import_typescript.factory.createStringLiteral(schemaPath)));
 			const compilerOptionsAssignment = import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral("compilerOptions"), import_typescript.factory.createObjectLiteralExpression([import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral("plugins"), import_typescript.factory.createArrayLiteralExpression([createLspPluginObject(target)], true))], true));
 			const nextProperties = rootObj.properties.map((property) => {
-				if (schemaProperty && property === schemaProperty) return schemaPropertyAssignment;
+				if (schemaProperty && property === schemaProperty && isSome(schemaPropertyAssignment)) return schemaPropertyAssignment.value;
 				return property;
 			});
-			if (shouldAddSchema) nextProperties.push(schemaPropertyAssignment);
+			if (shouldAddSchema && isSome(schemaPropertyAssignment)) nextProperties.push(schemaPropertyAssignment.value);
 			nextProperties.push(compilerOptionsAssignment);
 			tracker.replaceNode(current.sourceFile, rootObj, import_typescript.factory.createObjectLiteralExpression(nextProperties, true));
 		}).find((fc) => fc.fileName === current.sourceFile.fileName);
@@ -205260,7 +205453,7 @@ const computeTsConfigChanges = (current, target, lspVersion) => {
 	const fileChange = tsInternal.textChanges.ChangeTracker.with(ctx, (tracker) => {
 		const schemaProperty = findPropertyInObject(rootObj, "$schema");
 		const pluginsProperty = findPropertyInObject(compilerOptions, "plugins");
-		const schemaPropertyAssignment = import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral("$schema"), import_typescript.factory.createStringLiteral(TSCONFIG_SCHEMA_URL));
+		const schemaPropertyAssignment = map$10(target.schemaPath, (schemaPath) => import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral("$schema"), import_typescript.factory.createStringLiteral(schemaPath)));
 		if (isNone(lspVersion)) {
 			if (schemaProperty) {
 				descriptions.push("Remove $schema from tsconfig");
@@ -205281,12 +205474,12 @@ const computeTsConfigChanges = (current, target, lspVersion) => {
 				}
 			}
 		} else {
-			if (!schemaProperty) {
+			if (!schemaProperty && isSome(schemaPropertyAssignment)) {
 				descriptions.push("Add $schema to tsconfig");
-				insertNodeAtEndOfList(tracker, current.sourceFile, rootObj.properties, schemaPropertyAssignment);
-			} else if (!import_typescript.isStringLiteral(schemaProperty.initializer) || schemaProperty.initializer.text !== TSCONFIG_SCHEMA_URL) {
+				insertNodeAtEndOfList(tracker, current.sourceFile, rootObj.properties, schemaPropertyAssignment.value);
+			} else if (schemaProperty && isSome(target.schemaPath) && (!import_typescript.isStringLiteral(schemaProperty.initializer) || schemaProperty.initializer.text !== target.schemaPath.value)) {
 				descriptions.push("Update $schema in tsconfig");
-				tracker.replaceNode(current.sourceFile, schemaProperty.initializer, schemaPropertyAssignment.initializer);
+				tracker.replaceNode(current.sourceFile, schemaProperty.initializer, getOrThrow(schemaPropertyAssignment).initializer);
 			}
 			const pluginObject = createLspPluginObject(target);
 			if (!pluginsProperty) {
@@ -205350,18 +205543,19 @@ const computeVSCodeSettingsChanges = (current, target) => {
 	const rootObj = getRootObject(current.sourceFile);
 	if (!rootObj) return emptyFileChangesResult();
 	const ctx = createTrackerContext();
+	const createSettingValue = (value) => typeof value === "string" ? import_typescript.factory.createStringLiteral(value) : typeof value === "boolean" ? value ? import_typescript.factory.createTrue() : import_typescript.factory.createFalse() : Array.isArray(value) && value.every((item) => typeof item === "string") ? import_typescript.factory.createArrayLiteralExpression(value.map((item) => import_typescript.factory.createStringLiteral(item))) : import_typescript.factory.createNull();
 	const fileChange = tsInternal.textChanges.ChangeTracker.with(ctx, (tracker) => {
 		if (rootObj.properties.length === 0) {
 			const newProperties = [];
 			for (const [key, value] of Object.entries(target.settings)) {
 				descriptions.push(`Add ${key} setting`);
-				newProperties.push(import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral(key), typeof value === "string" ? import_typescript.factory.createStringLiteral(value) : typeof value === "boolean" ? value ? import_typescript.factory.createTrue() : import_typescript.factory.createFalse() : import_typescript.factory.createNull()));
+				newProperties.push(import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral(key), createSettingValue(value)));
 			}
 			const newRootObj = import_typescript.factory.createObjectLiteralExpression(newProperties, true);
 			tracker.replaceNode(current.sourceFile, rootObj, newRootObj);
 		} else for (const [key, value] of Object.entries(target.settings)) if (!findPropertyInObject(rootObj, key)) {
 			descriptions.push(`Add ${key} setting`);
-			const newProp = import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral(key), typeof value === "string" ? import_typescript.factory.createStringLiteral(value) : typeof value === "boolean" ? value ? import_typescript.factory.createTrue() : import_typescript.factory.createFalse() : import_typescript.factory.createNull());
+			const newProp = import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral(key), createSettingValue(value));
 			insertNodeAtEndOfList(tracker, current.sourceFile, rootObj.properties, newProp);
 		}
 	}).find((fc) => fc.fileName === current.path);
@@ -206622,6 +206816,23 @@ var rules = [
 			}]
 		}
 	},
+	{
+		"name": "flatMapToMap",
+		"group": "style",
+		"description": "Suggests using Effect.map instead of Effect.flatMap when the callback only wraps its result with Effect.succeed",
+		"defaultSeverity": "suggestion",
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377100],
+		"preview": {
+			"sourceText": "import { Effect } from \"effect\"\n\nconst program = Effect.succeed(1).pipe(\n  Effect.flatMap((value) => Effect.succeed(value + 1))\n)\n",
+			"diagnostics": [{
+				"start": 75,
+				"end": 89,
+				"text": "`Effect.map` expresses this success-value transformation more directly than `Effect.flatMap` followed by `Effect.succeed`. effect(flatMapToMap)"
+			}]
+		}
+	},
 	{
 		"name": "missedPipeableOpportunity",
 		"group": "style",
@@ -207361,7 +207572,10 @@ const fromAssessment = (inputState) => ({
 		typescriptVersion: inputState.packageJson.typescriptVersion,
 		prepareScript: map$10(inputState.packageJson.prepareScript, (_) => _.hasPatch).pipe(getOrElse$1(() => false))
 	},
-	tsconfig: { diagnosticSeverities: inputState.tsconfig.currentDiagnosticSeverities },
+	tsconfig: {
+		schemaPath: inputState.tsconfig.currentSchemaPath,
+		diagnosticSeverities: inputState.tsconfig.currentDiagnosticSeverities
+	},
 	vscodeSettings: map$10(inputState.vscodeSettings, (settings) => ({ settings: settings.parsed })),
 	editors: []
 });
@@ -207385,7 +207599,7 @@ const findTsConfigFiles = (currentDir) => gen(function* () {
 	const files = yield* fs.readDirectory(currentDir);
 	return filter$2(files, isTsConfigFile).map((file) => path.join(currentDir, file));
 });
-const promptForTsConfigPath = (currentDir) => file({
+const promptForTsConfigPath = (currentDir) => file$2({
 	type: "file",
 	message: "Select tsconfig to configure",
 	startingPath: currentDir,
@@ -207443,6 +207657,21 @@ const configCommand = make("config").pipe(withDescription("Configure diagnostic
 	});
 })));
 
+//#endregion
+//#region src/diagnostics.ts
+const runDiagnosticsBinary = (binaryPath, request, spawn = node_child_process.spawnSync) => {
+	const result = spawn(binaryPath, ["--effect-cli-diagnostics", JSON.stringify(request)], { stdio: "inherit" });
+	if (result.error !== void 0) throw result.error;
+	return result;
+};
+const propagateDiagnosticsExit = (result, parent = process) => {
+	if (result.signal !== null) {
+		parent.kill(parent.pid, result.signal);
+		return;
+	}
+	parent.exitCode = result.status ?? 1;
+};
+
 //#endregion
 //#region src/presets.ts
 const metadata = metadata_default;
@@ -207501,6 +207730,7 @@ function isPresetEnabled(presetName, severities) {
 * Gather target state from user based on current assessment
 */
 const gatherTargetState = (assessment, context) => gen(function* () {
+	const path = yield* Path;
 	const currentLspState = match$8(assessment.packageJson.lspVersion, {
 		onNone: () => "no",
 		onSome: (lsp) => lsp.dependencyType
@@ -207533,7 +207763,10 @@ const gatherTargetState = (assessment, context) => gen(function* () {
 			typescriptVersion: assessment.packageJson.typescriptVersion,
 			prepareScript: false
 		},
-		tsconfig: { diagnosticSeverities: none$3() },
+		tsconfig: {
+			schemaPath: none$3(),
+			diagnosticSeverities: none$3()
+		},
 		vscodeSettings: none$3(),
 		editors: []
 	};
@@ -207578,10 +207811,12 @@ const gatherTargetState = (assessment, context) => gen(function* () {
 		]
 	});
 	const defaultTypescriptPackageName = defaultTypescriptPackageNames[0];
+	const relativeSchemaPath = path.relative(path.dirname(assessment.tsconfig.path), context.defaultSchemaPath).replaceAll("\\", "/");
 	const vscodeSettings = editors.includes("vscode") ? some({ settings: {
-		"typescript.native-preview.tsdk": nativeBackendTsdkPath(defaultTypescriptPackageName),
-		"typescript.experimental.useTsgo": true,
-		"js/ts.experimental.useTsgo": true
+		"js/ts.experimental.useTsgo": true,
+		"js/ts.tsdk.path": "./node_modules/typescript/bin",
+		"js/ts.tsdk.promptToUseWorkspaceVersion": true,
+		"js/ts.tsdk.additionalLocations": ["./node_modules/typescript/bin"]
 	} }) : none$3();
 	return {
 		packageJson: {
@@ -207596,7 +207831,10 @@ const gatherTargetState = (assessment, context) => gen(function* () {
 			})),
 			prepareScript: true
 		},
-		tsconfig: { diagnosticSeverities },
+		tsconfig: {
+			schemaPath: some(relativeSchemaPath.startsWith(".") ? relativeSchemaPath : `./${relativeSchemaPath}`),
+			diagnosticSeverities
+		},
 		vscodeSettings,
 		editors
 	};
@@ -207604,18 +207842,20 @@ const gatherTargetState = (assessment, context) => gen(function* () {
 
 //#endregion
 //#region upstream.json
-var tsVersion = "7.1.0-dev.20260708.3";
+var tsVersion = "7.1.0-dev.20260713.1";
 
 //#endregion
 //#region src/setup/index.ts
 const setupCommand = make("setup").pipe(withDescription("Setup @effect/tsgo for the given project using an interactive CLI."), withHandler(() => gen(function* () {
-	const currentDir = (yield* Path).resolve(process.cwd());
+	const path = yield* Path;
+	const currentDir = path.resolve(process.cwd());
 	const tsconfigInput = yield* selectTsConfigFile(currentDir);
 	const assessmentInput = yield* createAssessmentInput(currentDir, tsconfigInput);
 	const assessmentState = assess(assessmentInput);
 	const targetState = yield* gatherTargetState(assessmentState, {
 		defaultLspVersion: version,
-		defaultTypescriptVersion: tsVersion
+		defaultTypescriptVersion: tsVersion,
+		defaultSchemaPath: path.resolve(currentDir, "node_modules", name, "schema.json")
 	});
 	const result = computeChanges(assessmentState, targetState);
 	yield* reviewAndApplyChanges(result, assessmentState, { cancelMessage: "Setup cancelled. No changes were made." });
@@ -207921,10 +208161,36 @@ const patchCommand = make("patch", {
 }).pipe(withDescription("Patch the Effect Language Service binary"), withHandler(({ force, typescriptPackage }) => patch(force, packageNamesWithPreferred(typescriptPackage))));
 const unpatchCommand = make("unpatch").pipe(withDescription("Unpatch and restore the original TypeScript-Go binary"), withHandler(() => unpatch));
 const getExePathCommand = make("get-exe-path").pipe(withDescription("Print the Effect Language Service executable path"), withHandler(() => resolveInstalledTypeScriptBinary(defaultTypescriptPackageNames).pipe(flatMap((installedTypeScript) => getPackagedBinaryPath(installedTypeScript, false)), flatMap((exePath) => log(exePath)))));
+const diagnosticsCommand = make("diagnostics", {
+	file: file("file").pipe(optional, withDescription$1("The full path of the file to check for diagnostics")),
+	project: file("project").pipe(optional, withDescription$1("The full path of the project tsconfig.json file to check for diagnostics")),
+	format: choice("format", [
+		"json",
+		"pretty",
+		"text",
+		"github-actions"
+	]).pipe(withDefault("pretty"), withDescription$1("Output format: json (machine-readable), pretty (colored with context), text (plain text), github-actions (workflow commands)")),
+	strict: boolean("strict").pipe(withDefault(false), withDescription$1("Treat warnings as errors (affects exit code)")),
+	severity: string("severity").pipe(optional, withDescription$1("Filter by severity levels (comma-separated: error,warning,message)")),
+	progress: boolean("progress").pipe(withDefault(false), withDescription$1("Show progress as files are checked (outputs to stderr)")),
+	lspconfig: string("lspconfig").pipe(optional, withDescription$1("An optional inline JSON lsp config that replaces the current project lsp config"))
+}).pipe(withDescription("Gets the Effect language service diagnostics on the given files or project"), withHandler(({ file, format, lspconfig, progress, project, severity, strict }) => gen(function* () {
+	propagateDiagnosticsExit(runDiagnosticsBinary(yield* getPackagedBinaryPath(yield* resolveInstalledTypeScriptBinary(defaultTypescriptPackageNames), false), {
+		cwd: process.cwd(),
+		file: getOrUndefined(file),
+		project: getOrUndefined(project),
+		format,
+		strict,
+		severity: getOrUndefined(severity),
+		progress,
+		lspconfig: getOrUndefined(lspconfig)
+	}));
+})));
 make("tsgo").pipe(withSubcommands([
 	patchCommand,
 	unpatchCommand,
 	getExePathCommand,
+	diagnosticsCommand,
 	setupCommand,
 	configCommand
 ])).pipe(run({ version }), provide(layer), runMain());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/tsgo",
-  "version": "0.18.1",
+  "version": "0.20.0",
   "description": "Effect Language Service for TypeScript-Go — Effect-specific diagnostics and hover features.",
   "license": "MIT",
   "repository": {
@@ -19,16 +19,17 @@
   },
   "files": [
     "dist/",
-    "README.md"
+    "README.md",
+    "schema.json"
   ],
   "optionalDependencies": {
-    "@effect/tsgo-win32-x64": "0.18.1",
-    "@effect/tsgo-win32-arm64": "0.18.1",
-    "@effect/tsgo-linux-x64": "0.18.1",
-    "@effect/tsgo-linux-arm64": "0.18.1",
-    "@effect/tsgo-linux-arm": "0.18.1",
-    "@effect/tsgo-darwin-x64": "0.18.1",
-    "@effect/tsgo-darwin-arm64": "0.18.1"
+    "@effect/tsgo-win32-x64": "0.20.0",
+    "@effect/tsgo-win32-arm64": "0.20.0",
+    "@effect/tsgo-linux-x64": "0.20.0",
+    "@effect/tsgo-linux-arm64": "0.20.0",
+    "@effect/tsgo-linux-arm": "0.20.0",
+    "@effect/tsgo-darwin-x64": "0.20.0",
+    "@effect/tsgo-darwin-arm64": "0.20.0"
   },
   "devDependencies": {
     "@effect/platform-node": "^4.0.0-beta.83",