@effect/language-service 0.57.0 → 0.58.0

package/cli.js

@@ -867,7 +867,7 @@ var require_getParsedConfigFile = __commonJS({
           throw new Error(formatDiagnostics([diag]));
         },
         readDirectory: tsserver.sys.readDirectory,
-        readFile: (file6) => fs.readFileSync(path2.isAbsolute(file6) ? file6 : path2.join(getCurrentDirectory(), file6), "utf-8"),
+        readFile: (file5) => fs.readFileSync(path2.isAbsolute(file5) ? file5 : path2.join(getCurrentDirectory(), file5), "utf-8"),
         useCaseSensitiveFileNames: tsserver.sys.useCaseSensitiveFileNames
       });
       if (parsed?.errors.length) {
@@ -7113,18 +7113,18 @@ var fromFlatLoop = (flat, prefix, config2, split2) => {
   }
 };
 var fromFlatLoopFail = (prefix, path2) => (index) => left2(MissingData(prefix, `The element at index ${index} in a sequence at path "${path2}" was missing`));
-var splitPathString = (text8, delim) => {
-  const split2 = text8.split(new RegExp(`\\s*${escape(delim)}\\s*`));
+var splitPathString = (text9, delim) => {
+  const split2 = text9.split(new RegExp(`\\s*${escape(delim)}\\s*`));
   return split2;
 };
-var parsePrimitive = (text8, path2, primitive2, delimiter, split2) => {
+var parsePrimitive = (text9, path2, primitive2, delimiter, split2) => {
   if (!split2) {
-    return pipe(primitive2.parse(text8), mapBoth2({
+    return pipe(primitive2.parse(text9), mapBoth2({
       onFailure: prefixed(path2),
       onSuccess: of
     }));
   }
-  return pipe(splitPathString(text8, delimiter), forEachSequential((char4) => primitive2.parse(char4.trim())), mapError(prefixed(path2)));
+  return pipe(splitPathString(text9, delimiter), forEachSequential((char4) => primitive2.parse(char4.trim())), mapError(prefixed(path2)));
 };
 var transpose = (array7) => {
   return Object.keys(array7[0]).map((column3) => array7.map((row) => row[column3]));
@@ -9226,14 +9226,14 @@ var structuredMessage = (u) => {
     }
   }
 };
-var withColor = (text8, ...colors2) => {
+var withColor = (text9, ...colors2) => {
   let out = "";
   for (let i = 0; i < colors2.length; i++) {
     out += `\x1B[${colors2[i]}m`;
   }
-  return out + text8 + "\x1B[0m";
+  return out + text9 + "\x1B[0m";
 };
-var withColorNoop = (text8, ..._colors) => text8;
+var withColorNoop = (text9, ..._colors) => text9;
 var colors = {
   bold: "1",
   red: "31",
@@ -15196,10 +15196,10 @@ var char = (char4) => {
   op.char = char4;
   return op;
 };
-var text = (text8) => {
+var text = (text9) => {
   const op = Object.create(proto5);
   op._tag = "Text";
-  op.text = text8;
+  op.text = text9;
   return op;
 };
 var flatAlt = /* @__PURE__ */ dual(2, (self, that) => {
@@ -15488,10 +15488,10 @@ var char2 = /* @__PURE__ */ dual(2, (self, char4) => {
   op.stream = self;
   return op;
 });
-var text2 = /* @__PURE__ */ dual(2, (self, text8) => {
+var text2 = /* @__PURE__ */ dual(2, (self, text9) => {
   const op = Object.create(proto6);
   op._tag = "TextStream";
-  op.text = text8;
+  op.text = text9;
   op.stream = self;
   return op;
 });
@@ -16309,8 +16309,8 @@ var make44 = (bytes) => {
   redactedRegistry.set(secret4, bytes.map((byte) => String.fromCharCode(byte)).join(""));
   return secret4;
 };
-var fromString = (text8) => {
-  return make44(text8.split("").map((char4) => char4.charCodeAt(0)));
+var fromString = (text9) => {
+  return make44(text9.split("").map((char4) => char4.charCodeAt(0)));
 };
 
 // node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/config.js
@@ -18888,7 +18888,7 @@ var defaultConfig = {
   showBuiltIns: true,
   showTypes: true
 };
-var normalizeCase = /* @__PURE__ */ dual(2, (self, text8) => self.isCaseSensitive ? text8 : text8.toLowerCase());
+var normalizeCase = /* @__PURE__ */ dual(2, (self, text9) => self.isCaseSensitive ? text9 : text9.toLowerCase());
 
 // node_modules/.pnpm/@effect+cli@0.72.0_@effect+platform@0.93.0_@effect+printer-ansi@0.47.0_@effect+printer@0.47.0_effect@3.19.0/node_modules/@effect/cli/dist/esm/internal/autoCorrect.js
 var levensteinDistance = (first3, second, config2) => {
@@ -22834,11 +22834,11 @@ var make53 = (impl) => {
     }),
     stream: (path2, options3) => pipe(impl.open(path2, {
       flag: "r"
-    }), options3?.offset ? tap2((file6) => file6.seek(options3.offset, "start")) : identity, map17((file6) => stream(file6, options3)), unwrapScoped6),
+    }), options3?.offset ? tap2((file5) => file5.seek(options3.offset, "start")) : identity, map17((file5) => stream(file5, options3)), unwrapScoped6),
     sink: (path2, options3) => pipe(impl.open(path2, {
       flag: "w",
       ...options3
-    }), map17((file6) => forEach10((_) => file6.writeAll(_))), unwrapScoped5),
+    }), map17((file5) => forEach10((_) => file5.writeAll(_))), unwrapScoped5),
     writeFileString: (path2, data, options3) => flatMap9(try_3({
       try: () => new TextEncoder().encode(data),
       catch: (cause2) => new BadArgument({
@@ -22850,7 +22850,7 @@ var make53 = (impl) => {
     }), (_) => impl.writeFile(path2, _, options3))
   });
 };
-var stream = (file6, {
+var stream = (file5, {
   bufferSize = 16,
   bytesToRead: bytesToRead_,
   chunkSize: chunkSize_ = Size(64 * 1024)
@@ -22862,7 +22862,7 @@ var stream = (file6, {
       return void_6;
     }
     const toRead = bytesToRead !== void 0 && bytesToRead - totalBytesRead < chunkSize ? bytesToRead - totalBytesRead : chunkSize;
-    return flatMap15(file6.readAlloc(toRead), match2({
+    return flatMap15(file5.readAlloc(toRead), match2({
       onNone: () => void_6,
       onSome: (buf) => flatMap15(write2(of2(buf)), (_) => loop2(totalBytesRead + BigInt(buf.length)))
     }));
@@ -23161,12 +23161,12 @@ var windowsFigures = {
   pointer: /* @__PURE__ */ text3(">")
 };
 var figures = /* @__PURE__ */ map17(/* @__PURE__ */ sync4(() => process.platform === "win32"), (isWindows) => isWindows ? windowsFigures : defaultFigures);
-function eraseText(text8, columns) {
+function eraseText(text9, columns) {
   if (columns === 0) {
     return cat2(eraseLine3, cursorTo3(0));
   }
   let rows = 0;
-  const lines3 = text8.split(/\r?\n/);
+  const lines3 = text9.split(/\r?\n/);
   for (const line4 of lines3) {
     rows += 1 + Math.floor(Math.max(line4.length - 1, 0) / columns);
   }
@@ -24168,10 +24168,10 @@ function getFileList(directory3, options3) {
       // to be filtered out if the user so desires
       map17((files2) => ["..", ...files2])
     );
-    return yield* filter8(files, (file6) => {
-      const result = options3.filter(file6);
+    return yield* filter8(files, (file5) => {
+      const result = options3.filter(file5);
       const userDefinedFilter = isEffect2(result) ? result : succeed7(result);
-      const directoryFilter = options3.type === "directory" ? map17(orDie2(fs.stat(path2.join(directory3, file6))), (info2) => info2.type === "Directory") : succeed7(true);
+      const directoryFilter = options3.type === "directory" ? map17(orDie2(fs.stat(path2.join(directory3, file5))), (info2) => info2.type === "Directory") : succeed7(true);
       return zipWith4(userDefinedFilter, directoryFilter, (a, b) => a && b);
     }, {
       concurrency: files.length
@@ -24184,12 +24184,12 @@ function handleClear2(options3) {
       const terminal = yield* Terminal;
       const columns = yield* terminal.columns;
       const currentPath = yield* resolveCurrentPath(state.path, options3);
-      const text8 = "\n".repeat(Math.min(state.files.length, options3.maxPerPage));
+      const text9 = "\n".repeat(Math.min(state.files.length, options3.maxPerPage));
       const clearPath = eraseText(currentPath, columns);
       const message = showConfirmation(state.confirm) ? CONFIRM_MESSAGE : options3.message;
       const clearPrompt = eraseText(`
 ${message}`, columns);
-      const clearOptions = eraseText(text8, columns);
+      const clearOptions = eraseText(text9, columns);
       return clearOptions.pipe(cat2(clearPath), cat2(clearPrompt), optimize3(Deep), render3({
         style: "pretty",
         options: {
@@ -24220,8 +24220,8 @@ function renderPrefix(state, toDisplay, currentIndex, length3, figures2) {
   }
   return state.cursor === currentIndex ? figures2.pointer.pipe(annotate2(cyanBright2), cat2(prefix)) : prefix.pipe(cat2(space2));
 }
-function renderFileName(file6, isSelected) {
-  return isSelected ? annotate2(text3(file6), combine10(underlined2, cyanBright2)) : text3(file6);
+function renderFileName(file5, isSelected) {
+  return isSelected ? annotate2(text3(file5), combine10(underlined2, cyanBright2)) : text3(file5);
 }
 function renderFiles(state, files, figures2, options3) {
   const length3 = files.length;
@@ -24325,7 +24325,7 @@ function processSelection(state, options3) {
     const info2 = yield* orDie2(fs.stat(resolvedPath));
     if (info2.type === "Directory") {
       const files = yield* getFileList(resolvedPath, options3);
-      const filesWithoutParent = files.filter((file6) => file6 !== "..");
+      const filesWithoutParent = files.filter((file5) => file5 !== "..");
       if (options3.type === "directory" || options3.type === "either") {
         return filesWithoutParent.length === 0 ? Action.Submit({
           value: resolvedPath
@@ -24899,8 +24899,8 @@ function handleClear4(options3) {
     const terminal = yield* Terminal;
     const columns = yield* terminal.columns;
     const clearPrompt = cat2(eraseLine3, cursorLeft3);
-    const text8 = "\n".repeat(Math.min(options3.choices.length, options3.maxPerPage)) + options3.message;
-    const clearOutput = eraseText(text8, columns);
+    const text9 = "\n".repeat(Math.min(options3.choices.length, options3.maxPerPage)) + options3.message;
+    const clearOutput = eraseText(text9, columns);
     return clearOutput.pipe(cat2(clearPrompt), optimize3(Deep), render3({
       style: "pretty",
       options: {
@@ -25000,7 +25000,7 @@ ${error4}`, columns))
   });
 }
 function renderInput2(nextState, options3, submitted) {
-  const text8 = getValue(nextState, options3);
+  const text9 = getValue(nextState, options3);
   const annotation = match2(nextState.error, {
     onNone: () => {
       if (submitted) {
@@ -25018,10 +25018,10 @@ function renderInput2(nextState, options3, submitted) {
       return empty32;
     }
     case "password": {
-      return annotate2(text3("*".repeat(text8.length)), annotation);
+      return annotate2(text3("*".repeat(text9.length)), annotation);
     }
     case "text": {
-      return annotate2(text3(text8), annotation);
+      return annotate2(text3(text9), annotation);
     }
   }
 }
@@ -25401,6 +25401,11 @@ var path = (pathType, pathExists) => {
   op.pathExists = pathExists;
   return op;
 };
+var text6 = /* @__PURE__ */ (() => {
+  const op = /* @__PURE__ */ Object.create(proto19);
+  op._tag = "Text";
+  return op;
+})();
 var getChoices = (self) => getChoicesInternal(self);
 var getHelp = (self) => getHelpInternal(self);
 var getTypeName = (self) => getTypeNameInternal(self);
@@ -26032,6 +26037,7 @@ var none10 = /* @__PURE__ */ (() => {
   op._tag = "Empty";
   return op;
 })();
+var text7 = (name) => makeSingle(name, empty2(), text6);
 var getHelp3 = (self) => getHelpInternal2(self);
 var getUsage = (self) => getUsageInternal(self);
 var map29 = /* @__PURE__ */ dual(2, (self, f) => makeMap(self, (a) => right2(f(a))));
@@ -26994,6 +27000,7 @@ var boolean5 = boolean4;
 var choice3 = choice2;
 var directory2 = directory;
 var file3 = file2;
+var text8 = text7;
 var optional4 = optional3;
 var repeated4 = repeated3;
 var withDefault3 = withDefault2;
@@ -27212,7 +27219,7 @@ var validateInternal2 = (self, args3, config2) => {
             return fail7(missingValue(p(`Missing argument ${getTypeName(self.primitiveType)}`)));
           },
           onNonEmpty: (head5, tail) => validate4(self.primitiveType, some2(head5), config2).pipe(mapBoth4({
-            onFailure: (text8) => invalidArgument(p(text8)),
+            onFailure: (text9) => invalidArgument(p(text9)),
             onSuccess: (a) => [tail, a]
           }))
         });
@@ -28080,10 +28087,10 @@ var handleBuiltInOption = (self, executable, args3, builtIn2, execute2, config2)
       const description = descriptionList([[text4("Instructions"), instructions]]);
       const header = h1(spans([code("Wizard Mode for CLI Application:"), space3, code(self.name), space3, code(`(${self.version})`), summary5]));
       const help = sequence(header, description);
-      const text8 = toAnsiText(help);
+      const text9 = toAnsiText(help);
       const command = fromIterable(getNames2(self.command))[0];
       const wizardPrefix = getWizardPrefix(builtIn2, command, args3);
-      return log3(text8).pipe(zipRight3(wizard4(builtIn2.command, wizardPrefix, config2)), tap2((args4) => log3(toAnsiText(renderWizardArgs(args4)))), flatMap9((args4) => toggle2({
+      return log3(text9).pipe(zipRight3(wizard4(builtIn2.command, wizardPrefix, config2)), tap2((args4) => log3(toAnsiText(renderWizardArgs(args4)))), flatMap9((args4) => toggle2({
         message: "Would you like to run the command?",
         initial: true,
         active: "yes",
@@ -28899,7 +28906,7 @@ var makeTempFile = /* @__PURE__ */ makeTempFileFactory("makeTempFile");
 var makeTempFileScoped = /* @__PURE__ */ (() => {
   const makeFile2 = /* @__PURE__ */ makeTempFileFactory("makeTempFileScoped");
   const removeDirectory = /* @__PURE__ */ removeFactory("makeTempFileScoped");
-  return (options3) => acquireRelease2(makeFile2(options3), (file6) => orDie2(removeDirectory(Path3.dirname(file6), {
+  return (options3) => acquireRelease2(makeFile2(options3), (file5) => orDie2(removeDirectory(Path3.dirname(file5), {
     recursive: true
   })));
 })();
@@ -33538,18 +33545,18 @@ var BATCH_SIZE = 50;
 var codegen = make58(
   "codegen",
   { file: file4, project: project2, verbose },
-  fn("codegen")(function* ({ file: file6, project: project4, verbose: verbose2 }) {
+  fn("codegen")(function* ({ file: file5, project: project3, verbose: verbose2 }) {
     const path2 = yield* Path2;
     const fs = yield* FileSystem;
     const tsInstance = yield* getTypeScript;
     let filesToCodegen = /* @__PURE__ */ new Set();
     let checkedFilesCount = 0;
     let updatedFilesCount = 0;
-    if (isSome2(project4)) {
-      filesToCodegen = yield* getFileNamesInTsConfig(project4.value);
+    if (isSome2(project3)) {
+      filesToCodegen = yield* getFileNamesInTsConfig(project3.value);
     }
-    if (isSome2(file6)) {
-      filesToCodegen.add(path2.resolve(file6.value));
+    if (isSome2(file5)) {
+      filesToCodegen.add(path2.resolve(file5.value));
     }
     if (filesToCodegen.size === 0) {
       return yield* new NoFilesToCodegenError();
@@ -33580,8 +33587,8 @@ var codegen = make58(
         try {
           const scriptInfo = service3.getScriptInfo(filePath);
           if (!scriptInfo) continue;
-          const project5 = scriptInfo.getDefaultProject();
-          const languageService = project5.getLanguageService(true);
+          const project4 = scriptInfo.getDefaultProject();
+          const languageService = project4.getLanguageService(true);
           disposeIfLanguageServiceChanged(languageService);
           const program = languageService.getProgram();
           if (!program) continue;
@@ -33590,8 +33597,8 @@ var codegen = make58(
           const pluginConfig = extractEffectLspOptions(program.getCompilerOptions());
           if (!pluginConfig) continue;
           const formatContext = tsInstance.formatting.getFormatContext(
-            tsInstance.getDefaultFormatCodeSettings(project5.getNewLine()),
-            project5
+            tsInstance.getDefaultFormatCodeSettings(project4.getNewLine()),
+            project4
           );
           const allFileChanges = pipe(
             gen3(function* () {
@@ -33606,7 +33613,7 @@ var codegen = make58(
                   const changes2 = tsInstance.textChanges.ChangeTracker.with(
                     {
                       formatContext,
-                      host: project5,
+                      host: project4,
                       preferences: {}
                     },
                     (changeTracker) => pipe(
@@ -35528,6 +35535,11 @@ var runEffectInsideEffect = createDiagnostic({
   apply: fn2("runEffectInsideEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
+    const tsUtils = yield* service2(TypeScriptUtils);
+    const parseEffectMethod = (node, methodName) => pipe(
+      typeParser.isNodeReferenceToEffectModuleApi(methodName)(node),
+      map34(() => ({ node, methodName }))
+    );
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -35538,11 +35550,12 @@ var runEffectInsideEffect = createDiagnostic({
       const node = nodeToVisit.shift();
       ts.forEachChild(node, appendNodeToVisit);
       if (!ts.isCallExpression(node)) continue;
+      if (node.arguments.length === 0) continue;
       const isEffectRunCall = yield* pipe(
-        typeParser.isNodeReferenceToEffectModuleApi("runPromise")(node.expression),
-        orElse14(() => typeParser.isNodeReferenceToEffectModuleApi("runSync")(node.expression)),
-        orElse14(() => typeParser.isNodeReferenceToEffectModuleApi("runFork")(node.expression)),
-        orElse14(() => typeParser.isNodeReferenceToEffectModuleApi("runCallback")(node.expression)),
+        parseEffectMethod(node.expression, "runPromise"),
+        orElse14(() => parseEffectMethod(node.expression, "runSync")),
+        orElse14(() => parseEffectMethod(node.expression, "runFork")),
+        orElse14(() => parseEffectMethod(node.expression, "runCallback")),
         option4
       );
       if (isNone2(isEffectRunCall)) continue;
@@ -35562,18 +35575,90 @@ var runEffectInsideEffect = createDiagnostic({
           orElse14(() => typeParser.effectFnGen(possiblyEffectGen)),
           option4
         );
-        if (isSome2(isInEffectGen)) {
+        if (isSome2(isInEffectGen) && isInEffectGen.value.body.statements.length > 0) {
           const nodeText = sourceFile.text.substring(
             ts.getTokenPosOfNode(node.expression, sourceFile),
             node.expression.end
           );
-          const messageText = nodeIntroduceScope && nodeIntroduceScope !== isInEffectGen.value.generatorFunction ? `Using ${nodeText} inside an Effect is not recommended. The same runtime should generally be used instead to run child effects.
-Consider extracting the Runtime by using for example Effect.runtime and then use Runtime.run* with the extracted runtime instead.` : `Using ${nodeText} inside an Effect is not recommended. Effects inside generators can usually just be yielded.`;
-          report({
-            location: node.expression,
-            messageText,
-            fixes: []
-          });
+          if (nodeIntroduceScope && nodeIntroduceScope !== isInEffectGen.value.generatorFunction) {
+            const fixAddRuntime = gen3(function* () {
+              const changeTracker = yield* service2(ChangeTracker);
+              const runtimeModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Runtime") || "Runtime";
+              const effectModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Effect") || "Effect";
+              let runtimeIdentifier = void 0;
+              for (const statement of isInEffectGen.value.generatorFunction.body.statements) {
+                if (ts.isVariableStatement(statement) && statement.declarationList.declarations.length === 1) {
+                  const declaration = statement.declarationList.declarations[0];
+                  if (declaration.initializer && ts.isYieldExpression(declaration.initializer) && declaration.initializer.asteriskToken && declaration.initializer.expression) {
+                    const yieldedExpression = declaration.initializer.expression;
+                    if (ts.isCallExpression(yieldedExpression)) {
+                      const maybeEffectRuntime = yield* pipe(
+                        typeParser.isNodeReferenceToEffectModuleApi("runtime")(yieldedExpression.expression),
+                        option4
+                      );
+                      if (isSome2(maybeEffectRuntime) && ts.isIdentifier(declaration.name)) {
+                        runtimeIdentifier = ts.idText(declaration.name);
+                      }
+                    }
+                  }
+                }
+              }
+              if (!runtimeIdentifier) {
+                changeTracker.insertNodeAt(
+                  sourceFile,
+                  isInEffectGen.value.body.statements[0].pos,
+                  ts.factory.createVariableStatement(
+                    void 0,
+                    ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(
+                      "effectRuntime",
+                      void 0,
+                      void 0,
+                      ts.factory.createYieldExpression(
+                        ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+                        ts.factory.createCallExpression(
+                          ts.factory.createPropertyAccessExpression(
+                            ts.factory.createIdentifier(effectModuleIdentifier),
+                            "runtime"
+                          ),
+                          [ts.factory.createTypeReferenceNode("never")],
+                          []
+                        )
+                      )
+                    )], ts.NodeFlags.Const)
+                  ),
+                  {
+                    prefix: "\n",
+                    suffix: "\n"
+                  }
+                );
+              }
+              changeTracker.deleteRange(sourceFile, {
+                pos: ts.getTokenPosOfNode(node.expression, sourceFile),
+                end: node.arguments[0].pos
+              });
+              changeTracker.insertText(
+                sourceFile,
+                node.arguments[0].pos,
+                `${runtimeModuleIdentifier}.${isEffectRunCall.value.methodName}(${runtimeIdentifier || "effectRuntime"}, `
+              );
+            });
+            report({
+              location: node.expression,
+              messageText: `Using ${nodeText} inside an Effect is not recommended. The same runtime should generally be used instead to run child effects.
+Consider extracting the Runtime by using for example Effect.runtime and then use Runtime.${isEffectRunCall.value.methodName} with the extracted runtime instead.`,
+              fixes: [{
+                fixName: "runEffectInsideEffect_fix",
+                description: "Use a runtime to run the Effect",
+                apply: fixAddRuntime
+              }]
+            });
+          } else {
+            report({
+              location: node.expression,
+              messageText: `Using ${nodeText} inside an Effect is not recommended. Effects inside generators can usually just be yielded.`,
+              fixes: []
+            });
+          }
         }
         currentParent = currentParent.parent;
       }
@@ -36281,53 +36366,267 @@ var NoFilesToCheckError = class extends TaggedError("NoFilesToCheckError") {
     return "No files to check. Please provide an existing .ts file or a project tsconfig.json";
   }
 };
-var file5 = file3("file").pipe(
-  optional4,
-  withDescription3("The full path of the file to check for diagnostics.")
-);
-var project3 = file3("project").pipe(
-  optional4,
-  withDescription3("The full path of the project tsconfig.json file to check for diagnostics.")
-);
+var DiagnosticsFoundError = class extends TaggedError("DiagnosticsFoundError") {
+  get message() {
+    return `Found ${this.errorsCount} errors, ${this.warningsCount} warnings and ${this.messagesCount} messages.`;
+  }
+};
+var categoryToSeverity = (category, tsInstance) => {
+  switch (category) {
+    case tsInstance.DiagnosticCategory.Error:
+      return "error";
+    case tsInstance.DiagnosticCategory.Warning:
+      return "warning";
+    default:
+      return "message";
+  }
+};
+var formatDiagnosticForJson = (diagnostic, tsInstance) => {
+  if (!diagnostic.file || diagnostic.start === void 0) return void 0;
+  const { character, line: line4 } = tsInstance.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+  const endPos = diagnostic.start + (diagnostic.length ?? 0);
+  const { character: endCharacter, line: endLine } = tsInstance.getLineAndCharacterOfPosition(diagnostic.file, endPos);
+  const diagnosticName = Object.values(diagnostics).find((_) => _.code === diagnostic.code)?.name ?? `effect(${diagnostic.code})`;
+  return {
+    file: diagnostic.file.fileName,
+    line: line4 + 1,
+    column: character + 1,
+    endLine: endLine + 1,
+    endColumn: endCharacter + 1,
+    severity: categoryToSeverity(diagnostic.category, tsInstance),
+    code: diagnostic.code,
+    name: diagnosticName,
+    message: tsInstance.flattenDiagnosticMessageText(diagnostic.messageText, "\n")
+  };
+};
+var severityToGitHubCommand = (severity) => {
+  switch (severity) {
+    case "error":
+      return "error";
+    case "warning":
+      return "warning";
+    default:
+      return "notice";
+  }
+};
+var formatDiagnosticForGitHubActions = (diagnostic, tsInstance) => {
+  const output = formatDiagnosticForJson(diagnostic, tsInstance);
+  if (!output) return void 0;
+  const command = severityToGitHubCommand(output.severity);
+  const message = output.message.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
+  return `::${command} file=${output.file},line=${output.line},col=${output.column},endLine=${output.endLine},endColumn=${output.endColumn},title=${output.name}::${message}`;
+};
+var parseSeverityFilter = (severityOption) => {
+  if (isNone2(severityOption)) return void 0;
+  const levels = severityOption.value.split(",").map((s) => s.trim().toLowerCase());
+  const validLevels = /* @__PURE__ */ new Set();
+  for (const level of levels) {
+    if (level === "error" || level === "warning" || level === "message") {
+      validLevels.add(level);
+    }
+  }
+  return validLevels.size > 0 ? validLevels : void 0;
+};
+var diagnosticPrettyFormatter = gen2(function* () {
+  const path2 = yield* Path2;
+  return identity({
+    onBegin: () => _void,
+    onFile: () => _void,
+    onDiagnostics: (state, _filePath, diagnostics3) => sync4(() => {
+      const rawFormatted = state.tsInstance.formatDiagnosticsWithColorAndContext(diagnostics3, {
+        getCanonicalFileName: (fileName) => path2.resolve(fileName),
+        getCurrentDirectory: () => path2.resolve("."),
+        getNewLine: () => "\n"
+      });
+      return Object.values(diagnostics).reduce(
+        (text9, def) => text9.replace(new RegExp(`TS${def.code}:`, "g"), `effect(${def.name}):`),
+        rawFormatted
+      );
+    }).pipe(flatMap9(log3), when2(() => diagnostics3.length > 0)),
+    onEnd: (state) => log3(
+      `Checked ${state.checkedCount} files out of ${state.totalFilesCount} files. 
+${state.errorsCount} errors, ${state.warningsCount} warnings and ${state.messagesCount} messages.`
+    )
+  });
+});
+var diagnosticTextFormatter = gen2(function* () {
+  const path2 = yield* Path2;
+  return identity({
+    onBegin: () => _void,
+    onFile: () => _void,
+    onDiagnostics: (state, _filePath, diagnostics3) => sync4(() => {
+      const rawFormatted = state.tsInstance.formatDiagnostics(diagnostics3, {
+        getCanonicalFileName: (fileName) => path2.resolve(fileName),
+        getCurrentDirectory: () => path2.resolve("."),
+        getNewLine: () => "\n"
+      });
+      return Object.values(diagnostics).reduce(
+        (text9, def) => text9.replace(new RegExp(`TS${def.code}:`, "g"), `effect(${def.name}):`),
+        rawFormatted
+      );
+    }).pipe(flatMap9(log3), when2(() => diagnostics3.length > 0)),
+    onEnd: (state) => log3(
+      `Checked ${state.checkedCount} files out of ${state.totalFilesCount} files. 
+${state.errorsCount} errors, ${state.warningsCount} warnings and ${state.messagesCount} messages.`
+    )
+  });
+});
+var diagnosticJsonFormatter = gen2(function* () {
+  let hasEmittedDiagnostics = false;
+  return identity({
+    onBegin: () => log3(`{ "diagnostics": [`),
+    onFile: () => _void,
+    onDiagnostics: (state, _filePath, diagnostics3) => gen2(function* () {
+      for (const diagnostic of diagnostics3) {
+        const jsonDiagnostic = formatDiagnosticForJson(diagnostic, state.tsInstance);
+        if (jsonDiagnostic) {
+          if (hasEmittedDiagnostics) yield* log3(", ");
+          yield* log3(JSON.stringify(jsonDiagnostic, null, 2));
+          hasEmittedDiagnostics = true;
+        }
+      }
+    }),
+    onEnd: (state) => log3(`], "summary": ${JSON.stringify(
+      {
+        filesChecked: state.checkedCount,
+        totalFiles: state.totalFilesCount,
+        errors: state.errorsCount,
+        warnings: state.warningsCount,
+        messages: state.messagesCount
+      },
+      null,
+      2
+    )} }`)
+  });
+});
+var diagnosticGitHubActionsFormatter = gen2(function* () {
+  return identity({
+    onBegin: () => _void,
+    onFile: () => _void,
+    onDiagnostics: (state, _filePath, diagnostics3) => gen2(function* () {
+      if (diagnostics3.length === 0) return;
+      for (const diagnostic of diagnostics3) {
+        const formatted = formatDiagnosticForGitHubActions(diagnostic, state.tsInstance);
+        if (formatted) {
+          yield* log3(formatted);
+        }
+      }
+    }),
+    onEnd: (state) => log3(
+      `Checked ${state.checkedCount} files out of ${state.totalFilesCount} files. 
+${state.errorsCount} errors, ${state.warningsCount} warnings and ${state.messagesCount} messages.`
+    )
+  });
+});
+var withDiagnosticsProgressFormatter = (formatter) => gen2(function* () {
+  return identity({
+    onBegin: (state) => sync4(() => process.stderr.write(`Starting diagnostics for ${state.totalFilesCount} files...
+`)).pipe(
+      flatMap9(() => formatter.onBegin(state))
+    ),
+    onFile: (state, filePath) => sync4(
+      () => process.stderr.write(
+        `[${state.currentFileIndex}/${state.totalFilesCount}] ${filePath.slice(-60).padStart(60)}\r`
+      )
+    ).pipe(
+      flatMap9(() => formatter.onFile(state, filePath))
+    ),
+    onDiagnostics: (state, filePath, diagnostics3) => formatter.onDiagnostics(state, filePath, diagnostics3),
+    onEnd: (state) => sync4(() => process.stderr.write("\n")).pipe(
+      flatMap9(() => formatter.onEnd(state))
+    )
+  });
+});
 var BATCH_SIZE2 = 50;
 var diagnostics2 = make58(
   "diagnostics",
-  { file: file5, project: project3 },
-  fn("diagnostics")(function* ({ file: file6, project: project4 }) {
+  {
+    file: file3("file").pipe(
+      optional4,
+      withDescription3("The full path of the file to check for diagnostics.")
+    ),
+    project: file3("project").pipe(
+      optional4,
+      withDescription3("The full path of the project tsconfig.json file to check for diagnostics.")
+    ),
+    format: choice3("format", ["json", "pretty", "text", "github-actions"]).pipe(
+      withDefault3("pretty"),
+      withDescription3(
+        "Output format: json (machine-readable), pretty (colored with context), text (plain text), github-actions (workflow commands)"
+      )
+    ),
+    strict: boolean5("strict").pipe(
+      withDefault3(false),
+      withDescription3("Treat warnings as errors (affects exit code)")
+    ),
+    severity: text8("severity").pipe(
+      optional4,
+      withDescription3("Filter by severity levels (comma-separated: error,warning,message)")
+    ),
+    progress: boolean5("progress").pipe(
+      withDefault3(false),
+      withDescription3("Show progress as files are checked (outputs to stderr)")
+    )
+  },
+  fn("diagnostics")(function* ({ file: file5, format: format6, progress, project: project3, severity, strict: strict2 }) {
     const path2 = yield* Path2;
-    const tsInstance = yield* getTypeScript;
-    let filesToCheck = /* @__PURE__ */ new Set();
-    let checkedFilesCount = 0;
-    let errorsCount = 0;
-    let warningsCount = 0;
-    let messagesCount = 0;
-    if (isSome2(project4)) {
-      filesToCheck = yield* getFileNamesInTsConfig(project4.value);
-    }
-    if (isSome2(file6)) {
-      filesToCheck.add(path2.resolve(file6.value));
+    const severityFilter = parseSeverityFilter(severity);
+    const state = {
+      tsInstance: yield* getTypeScript,
+      checkedCount: 0,
+      errorsCount: 0,
+      warningsCount: 0,
+      messagesCount: 0,
+      languageService: void 0,
+      totalFilesCount: 0,
+      currentFileIndex: 0
+    };
+    const filesToCheck = isSome2(project3) ? yield* getFileNamesInTsConfig(project3.value) : /* @__PURE__ */ new Set();
+    if (isSome2(file5)) {
+      filesToCheck.add(path2.resolve(file5.value));
     }
     if (filesToCheck.size === 0) {
       return yield* new NoFilesToCheckError();
     }
-    const filesToCheckArray = fromIterable(filesToCheck);
-    const batches = chunksOf(filesToCheckArray, BATCH_SIZE2);
-    let lastLanguageService;
+    state.totalFilesCount = filesToCheck.size;
+    let reporter;
+    switch (format6) {
+      case "pretty":
+        reporter = yield* diagnosticPrettyFormatter;
+        break;
+      case "text":
+        reporter = yield* diagnosticTextFormatter;
+        break;
+      case "json":
+        reporter = yield* diagnosticJsonFormatter;
+        break;
+      case "github-actions":
+        reporter = yield* diagnosticGitHubActionsFormatter;
+        break;
+      default:
+        reporter = yield* diagnosticPrettyFormatter;
+    }
+    if (progress) {
+      reporter = yield* withDiagnosticsProgressFormatter(reporter);
+    }
+    yield* reporter.onBegin(state);
     const disposeIfLanguageServiceChanged = (languageService) => {
-      if (lastLanguageService !== languageService) {
-        lastLanguageService?.dispose();
-        lastLanguageService = languageService;
+      if (state.languageService !== languageService) {
+        state.languageService?.dispose();
+        state.languageService = languageService;
       }
     };
-    for (const batch of batches) {
+    for (const batch of chunksOf(filesToCheck, BATCH_SIZE2)) {
       const { service: service3 } = (0, import_project_service2.createProjectService)({ options: { loadTypeScriptPlugins: false } });
       for (const filePath of batch) {
+        state.currentFileIndex++;
+        yield* reporter.onFile(state, filePath);
         service3.openClientFile(filePath);
         try {
           const scriptInfo = service3.getScriptInfo(filePath);
           if (!scriptInfo) continue;
-          const project5 = scriptInfo.getDefaultProject();
-          const languageService = project5.getLanguageService(true);
+          const projectInfo = scriptInfo.getDefaultProject();
+          const languageService = projectInfo.getLanguageService(true);
           disposeIfLanguageServiceChanged(languageService);
           const program = languageService.getProgram();
           if (!program) continue;
@@ -36335,14 +36634,14 @@ var diagnostics2 = make58(
           if (!sourceFile) continue;
           const pluginConfig = extractEffectLspOptions(program.getCompilerOptions());
           if (!pluginConfig) continue;
-          const results = pipe(
+          const rawResults = pipe(
             getSemanticDiagnosticsWithCodeFixes(diagnostics, sourceFile),
             nanoLayer3,
             nanoLayer2,
             nanoLayer,
             provideService7(TypeCheckerApi, program.getTypeChecker()),
             provideService7(TypeScriptProgram, program),
-            provideService7(TypeScriptApi, tsInstance),
+            provideService7(TypeScriptApi, state.tsInstance),
             provideService7(
               LanguageServicePluginOptions,
               { ...parse4(pluginConfig), diagnosticsName: false }
@@ -36351,26 +36650,21 @@ var diagnostics2 = make58(
             map((_) => _.diagnostics),
             map(
               map4(
-                (_) => _.category === tsInstance.DiagnosticCategory.Suggestion ? { ..._, category: tsInstance.DiagnosticCategory.Message } : _
+                (_) => _.category === state.tsInstance.DiagnosticCategory.Suggestion ? { ..._, category: state.tsInstance.DiagnosticCategory.Message } : _
               )
             ),
             getOrElse(() => [])
           );
-          checkedFilesCount++;
-          errorsCount += results.filter((_) => _.category === tsInstance.DiagnosticCategory.Error).length;
-          warningsCount += results.filter((_) => _.category === tsInstance.DiagnosticCategory.Warning).length;
-          messagesCount += results.filter((_) => _.category === tsInstance.DiagnosticCategory.Message).length;
-          if (results.length > 0) {
-            let formattedResults = tsInstance.formatDiagnosticsWithColorAndContext(results, {
-              getCanonicalFileName: (fileName) => path2.resolve(fileName),
-              getCurrentDirectory: () => path2.resolve("."),
-              getNewLine: () => "\n"
-            });
-            Object.values(diagnostics).forEach(
-              (_) => formattedResults = formattedResults.replace(new RegExp(`TS${_.code}:`, "g"), `effect(${_.name}):`)
-            );
-            console.log(formattedResults);
-          }
+          const results = severityFilter ? rawResults.filter((d) => severityFilter.has(categoryToSeverity(d.category, state.tsInstance))) : rawResults;
+          state.checkedCount++;
+          state.errorsCount += results.filter((_) => _.category === state.tsInstance.DiagnosticCategory.Error).length;
+          state.warningsCount += results.filter(
+            (_) => _.category === state.tsInstance.DiagnosticCategory.Warning
+          ).length;
+          state.messagesCount += results.filter(
+            (_) => _.category === state.tsInstance.DiagnosticCategory.Message
+          ).length;
+          yield* reporter.onDiagnostics(state, filePath, results);
         } finally {
           service3.closeClientFile(filePath);
         }
@@ -36378,10 +36672,9 @@ var diagnostics2 = make58(
       yield* yieldNow4();
     }
     disposeIfLanguageServiceChanged(void 0);
-    console.log(
-      `Checked ${checkedFilesCount} files out of ${filesToCheck.size} files. 
-${errorsCount} errors, ${warningsCount} warnings and ${messagesCount} messages.`
-    );
+    yield* reporter.onEnd(state);
+    const hasFailures = state.errorsCount > 0 || strict2 && state.warningsCount > 0;
+    if (hasFailures) return yield* sync4(() => process.exit(1));
   })
 );
 
@@ -36428,8 +36721,8 @@ var getPatchesForModule = fn("getPatchesForModule")(
       }
       return find3(sourceFile2);
     }
-    function pushFunctionDeclarationNode(text8) {
-      const regex = new RegExp(text8, "ig");
+    function pushFunctionDeclarationNode(text9) {
+      const regex = new RegExp(text9, "ig");
       let pushed = false;
       let match18;
       while ((match18 = regex.exec(sourceFile.text)) !== null) {