@schlenkr/ragents 0.1.9 → 0.1.11

package/packages/workspace-executor/src/files.ts

@@ -18,7 +18,7 @@ export const FILE_OPERATIONS = {
   attach: "files.attach",
 } as const;
 
-/** Der Unterordner der Wurzel, in dem angehängte Dateien eines Runs liegen. */
+/** The subfolder of the root in which attached files of a run are stored. */
 export const ATTACHMENT_DIRECTORY = "attachments";
 
 export interface FileEntry {
@@ -29,7 +29,7 @@ export interface FileEntry {
 }
 
 export interface FileListing {
-  /** Der echte Pfad der Wurzel auf dieser Maschine. */
+  /** The real path of the root on this machine. */
   location: string;
   path: string;
   entries: FileEntry[];
@@ -40,7 +40,7 @@ export type FileText =
   | { path: string; size: number; previewable: true; content: string }
   | { path: string; size: number; previewable: false; reason: string };
 
-/** Erst `ready`, sobald die Beobachtung steht, danach je entprellter Änderung `changed`. */
+/** First `ready` once the watch is in place, then `changed` per debounced change. */
 export type FileWatchProgress = { kind: "ready" } | { kind: "changed" };
 
 export interface FileWatchListener {
@@ -57,11 +57,11 @@ const missing = (error: unknown): boolean => {
   return code === "ENOENT" || code === "ENOTDIR";
 };
 
-/** Ein Pfad unterhalb einer Wurzel: relativ, mit `/` getrennt und ohne `..`; `.` und leere Abschnitte fallen weg. */
+/** A path below a root: relative, separated by `/` and without `..`; `.` and empty segments are dropped. */
 export const relativeWorkspacePath = (value: string): string => {
   const segments = value.split("/").filter((segment) => segment !== "" && segment !== ".");
   if (value.includes("\0") || value.includes("\\") || path.isAbsolute(value) || segments.includes("..")) {
-    throw invalid(`Ungültiger Pfad: ${value}`);
+    throw invalid(`Invalid path: ${value}`);
   }
   return segments.join("/");
 };
@@ -70,25 +70,25 @@ const realRoot = async (root: string): Promise<string> => {
   try {
     return await realpath(root);
   } catch (error) {
-    if (missing(error)) throw notFound(`Den Ordner ${root} gibt es nicht`);
+    if (missing(error)) throw notFound(`The folder ${root} does not exist`);
     throw error;
   }
 };
 
-/** Löst einen geprüften relativen Pfad auf; ein Symlink darf nicht aus der Wurzel führen. */
+/** Resolves a checked relative path; a symlink must not lead out of the root. */
 const inside = async (base: string, relative: string): Promise<string> => {
   let real: string;
   try {
     real = await realpath(relative ? path.join(base, ...relative.split("/")) : base);
   } catch (error) {
-    if (missing(error)) throw notFound(`Nicht gefunden: ${relative || "."}`);
+    if (missing(error)) throw notFound(`Not found: ${relative || "."}`);
     throw error;
   }
-  if (!containsWorkspacePath(base, real)) throw invalid(`Pfad außerhalb des Arbeitsverzeichnisses: ${relative}`);
+  if (!containsWorkspacePath(base, real)) throw invalid(`Path outside the working directory: ${relative}`);
   return real;
 };
 
-/** Ein Eintrag, der zwischen Auflisten und Abfragen verschwindet, gehört nicht mehr zum Ordner. */
+/** An entry that disappears between listing and querying no longer belongs to the folder. */
 const entryOf = async (directory: string, name: string, isDirectory: boolean): Promise<FileEntry | undefined> => {
   try {
     const info = await lstat(path.join(directory, name));
@@ -105,15 +105,15 @@ const byKindThenName = (left: FileEntry, right: FileEntry): number =>
 
 const directoryIn = async (base: string, checked: string): Promise<string> => {
   const directory = await inside(base, checked);
-  if (!(await lstat(directory)).isDirectory()) throw invalid(`Kein Verzeichnis: ${checked || "."}`);
+  if (!(await lstat(directory)).isDirectory()) throw invalid(`Not a directory: ${checked || "."}`);
   return directory;
 };
 
-/** Der echte Pfad eines Ordners unterhalb der Wurzel, geprüft wie jeder Pfad dieses Moduls. */
+/** The real path of a folder below the root, checked like every path of this module. */
 export const workspaceDirectory = async (root: string, relative: string): Promise<string> =>
   directoryIn(await realRoot(root), relativeWorkspacePath(relative));
 
-/** Listet einen Ordner unterhalb der Wurzel: Ordner zuerst, dann alphabetisch, höchstens `FILE_LIST_LIMIT` Einträge. */
+/** Lists a folder below the root: folders first, then alphabetically, at most `FILE_LIST_LIMIT` entries. */
 export const listDirectory = async (root: string, relative: string): Promise<FileListing> => {
   const checked = relativeWorkspacePath(relative);
   const base = await realRoot(root);
@@ -130,26 +130,26 @@ export const listDirectory = async (root: string, relative: string): Promise<Fil
   };
 };
 
-/** Liest eine Textdatei unterhalb der Wurzel; eine zu große oder binäre Datei nennt statt des Inhalts den Grund. */
+/** Reads a text file below the root; a file that is too large or binary names the reason instead of the content. */
 export const readTextFile = async (root: string, relative: string): Promise<FileText> => {
   const checked = relativeWorkspacePath(relative);
   const file = await inside(await realRoot(root), checked);
   const info = await lstat(file);
-  if (!info.isFile()) throw invalid(`Keine Datei: ${checked || "."}`);
+  if (!info.isFile()) throw invalid(`Not a file: ${checked || "."}`);
   const described = { path: checked, size: info.size };
   if (info.size > FILE_READ_LIMIT) {
-    return { ...described, previewable: false, reason: `Die Datei ist größer als ${FILE_READ_LIMIT / 1024} KB und wird nicht gelesen` };
+    return { ...described, previewable: false, reason: `The file is larger than ${FILE_READ_LIMIT / 1024} KB and is not read` };
   }
   const content = await readFile(file);
-  if (content.includes(0)) return { ...described, previewable: false, reason: "Die Datei ist binär" };
+  if (content.includes(0)) return { ...described, previewable: false, reason: "The file is binary" };
   return { ...described, previewable: true, content: content.toString("utf8") };
 };
 
-/** Legt eine angehängte Datei unter einem freien Namen in `attachments` unterhalb der Wurzel ab, nie über eine vorhandene. */
+/** Stores an attached file under a free name in `attachments` below the root, never over an existing one. */
 export const storeAttachment = async (root: string, original: string, content: Uint8Array): Promise<string> => {
   const directory = path.join(await realRoot(root), ATTACHMENT_DIRECTORY);
   await mkdir(directory, { recursive: true, mode: 0o755 });
-  if (!(await lstat(directory)).isDirectory()) throw invalid("Das Anhangsverzeichnis ist kein normales Verzeichnis.");
+  if (!(await lstat(directory)).isDirectory()) throw invalid("The attachments directory is not a regular directory.");
   const name = path.basename(original).replace(/[^a-zA-Z0-9._-]/g, "_") || "attachment";
   for (let index = 1; index <= 10000; index += 1) {
     const candidate = index === 1 ? name : `${index}-${name}`;
@@ -160,10 +160,10 @@ export const storeAttachment = async (root: string, original: string, content: U
       if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
     }
   }
-  throw invalid("Im Anhangsverzeichnis sind zu viele gleichnamige Dateien.");
+  throw invalid("The attachments directory has too many files with the same name.");
 };
 
-/** Beobachtet einen Ordner rekursiv und meldet Änderungen entprellt; der Rückgabewert beendet die Beobachtung. */
+/** Watches a folder recursively and reports changes debounced; the return value ends the watch. */
 export const watchDirectory = async (root: string, listener: FileWatchListener): Promise<() => void> => {
   const directory = await realRoot(root);
   let debounce: NodeJS.Timeout | undefined;
@@ -183,17 +183,17 @@ export const watchDirectory = async (root: string, listener: FileWatchListener):
 
 const pathOf = (input: unknown): string => {
   const value = (input as { path?: unknown } | null)?.path;
-  if (typeof value !== "string") throw invalid("Die Eingabe braucht einen Pfad als Text");
+  if (typeof value !== "string") throw invalid("The input needs a path as text");
   return value;
 };
 
-/** Mit Alias spricht die Eingabe dessen Wurzel an, sonst die des Runs. */
+/** With an alias the input addresses its root, otherwise the one of the run. */
 const aliasFootprint = (input: unknown): OperationFootprint => {
   const alias = (input as { alias?: unknown } | null)?.alias;
   return { roots: typeof alias === "string" ? { aliases: [aliasOf(alias) ?? alias], runRoot: false } : { aliases: [], runRoot: true } };
 };
 
-/** Beobachtet bis zum Abbruch; eine gescheiterte Beobachtung beendet die Operation mit ihrer Ursache. */
+/** Watches until aborted; a failed watch ends the operation with its cause. */
 const watchUntilAborted = (root: string, signal: AbortSignal, progress: (value: FileWatchProgress) => void): Promise<null> =>
   new Promise((resolve, reject) => {
     let close: (() => void) | undefined;
@@ -219,16 +219,16 @@ const watchUntilAborted = (root: string, signal: AbortSignal, progress: (value:
     }, finish);
   });
 
-/** Dateien des Runs auf dieser Maschine: auflisten, Text lesen, beobachten und Anhänge ablegen, relativ zur Wurzel des Runs oder eines Alias. */
+/** Files of the run on this machine: list, read text, watch and store attachments, relative to the root of the run or of an alias. */
 export const fileModule: WorkspaceModuleFactory = (host) => {
-  /** Die offenen Beobachtungen je Run; Stopp und Shutdown beenden sie, auch wenn ihr Aufrufer nie abbricht. */
+  /** The open watches per run; stop and shutdown end them, even if their caller never aborts. */
   const watches = new Map<string, Set<AbortController>>();
   let closed = false;
   const endWatches = (runId: string): void => {
     for (const controller of watches.get(runId) ?? []) controller.abort();
     watches.delete(runId);
   };
-  /** Alias und Pfad bilden zusammen einen Ort; unter einem gemeinsamen Alias wie `@skills` nennt der Pfad zuerst den Ordner der Wurzel. */
+  /** Alias and path together form a location; under a shared alias like `@skills` the path names the folder of the root first. */
   const locate = async (runId: string, input: unknown): Promise<{ root: string; path: string }> => {
     const context = await host.contextFor(runId);
     const alias = (input as { alias?: unknown } | null)?.alias;
@@ -246,7 +246,7 @@ export const fileModule: WorkspaceModuleFactory = (host) => {
   };
   const attach: WorkspaceOperation = async ({ runId, input }) => {
     const { name, content } = (input ?? {}) as { name?: unknown; content?: unknown };
-    if (typeof name !== "string" || typeof content !== "string") throw invalid("Ein Anhang braucht name und content (Base64) als Text");
+    if (typeof name !== "string" || typeof content !== "string") throw invalid("An attachment needs name and content (Base64) as text");
     return { name: await storeAttachment((await host.contextFor(runId)).root, name, Buffer.from(content, "base64")) };
   };
   const read: WorkspaceOperation = async ({ runId, input }) => {
@@ -254,8 +254,8 @@ export const fileModule: WorkspaceModuleFactory = (host) => {
     return readTextFile(root, requested);
   };
   const watchFiles: WorkspaceOperation = async ({ runId, signal, progress }) => {
-    if (!signal || !progress) throw new Error(`${FILE_OPERATIONS.watch} läuft bis zum Abbruch und braucht Abbruchsignal und Fortschritt`);
-    if (closed) throw new Error("Das Dateimodul ist beendet und beobachtet nichts mehr");
+    if (!signal || !progress) throw new Error(`${FILE_OPERATIONS.watch} runs until aborted and needs an abort signal and progress`);
+    if (closed) throw new Error("The file module has ended and watches nothing anymore");
     const own = new AbortController();
     const running = watches.get(runId) ?? new Set<AbortController>();
     watches.set(runId, running.add(own));

package/packages/workspace-executor/src/language-server/contract.ts

@@ -27,7 +27,7 @@ export interface LanguageServerSnapshot {
 }
 
 export interface LanguageServerSolution {
-  /** Relativ zur Wurzel des Arbeitsbereichs, mit Schrägstrichen. */
+  /** Relative to the root of the workspace, with forward slashes. */
   path: string;
   root: string;
   state: LanguageServerState | null;
@@ -36,6 +36,6 @@ export interface LanguageServerSolution {
 export interface LanguageServerSolutions {
   source: "git" | "directory";
   solutions: readonly LanguageServerSolution[];
-  /** Ob im Run schon eine Instanz dieser Sprache offen ist oder gerade geöffnet wird. */
+  /** Whether an instance of this language is already open or being opened in the run. */
   opened: boolean;
 }

package/packages/workspace-executor/src/language-server/diagnostics.ts

@@ -51,12 +51,12 @@ export const formatDiagnostics = (
   const warnings = diagnostics.filter((diagnostic) => severityOf(diagnostic) === WARNING);
   const warningNote = warnings.length === 0
     ? ""
-    : `, ${warnings.length} ${warnings.length === 1 ? "Warnung" : "Warnungen"}`;
+    : `, ${warnings.length} ${warnings.length === 1 ? "warning" : "warnings"}`;
   const heading = errors.length === 0
-    ? `Diagnostik (${label}) ${relativePath}: keine Fehler${warningNote}`
-    : `Diagnostik (${label}) ${relativePath}: ${errors.length} Fehler${warningNote}`;
+    ? `Diagnostics (${label}) ${relativePath}: no errors${warningNote}`
+    : `Diagnostics (${label}) ${relativePath}: ${errors.length} ${errors.length === 1 ? "error" : "errors"}${warningNote}`;
   const listed = [...errors, ...(includeWarnings ? warnings : [])].sort(byPlace);
   const lines = listed.slice(0, MAX_LINES).map((diagnostic) => lineOf(relativePath, diagnostic));
-  if (listed.length > MAX_LINES) lines.push(`... und ${listed.length - MAX_LINES} weitere`);
+  if (listed.length > MAX_LINES) lines.push(`... and ${listed.length - MAX_LINES} more`);
   return [heading, ...lines].join("\n");
 };

package/packages/workspace-executor/src/language-server/host.ts

@@ -19,7 +19,7 @@ export interface LanguageServerAdapter {
   label: string;
   languages: Readonly<Record<string, string>>;
   rootDescription: string;
-  /** Die Endungen der Solutions, die `<id>_solutions` im Arbeitsbereich sucht; ohne sie gibt es weder Suche noch Umschalten. */
+  /** The extensions of the solutions that `<id>_solutions` searches for in the workspace; without them there is neither search nor switching. */
   solutionExtensions?: readonly string[];
   resolveRoot: (workspaceRoot: string, root: string) => Promise<string>;
   rootDirectory: (root: string) => string;
@@ -27,7 +27,7 @@ export interface LanguageServerAdapter {
   open: (session: LanguageServerSession, root: string, timeoutMs: number) => Promise<string>;
 }
 
-/** Was der Server über einen Sprachserver wissen muss, um Werkzeuge und Reiter zu beschreiben; gestartet wird er nur im Executor. */
+/** What the server must know about a language server to describe tools and tabs; it is only started in the executor. */
 export type LanguageServerDescription = Pick<LanguageServerAdapter, "id" | "label" | "languages" | "rootDescription" | "solutionExtensions">;
 
 export interface LanguageServerHostOptions {
@@ -64,7 +64,7 @@ const keyOf = (runId: string, root: string): string => `${runId}\n${root}`;
 
 const runOf = (key: string): string => key.slice(0, key.indexOf("\n"));
 
-const instanceCount = (count: number): string => `${count} offene Instanz${count === 1 ? "" : "en"}`;
+const instanceCount = (count: number): string => `${count} open instance${count === 1 ? "" : "s"}`;
 
 const git = async (
   context: WorkspaceProcessContext,
@@ -73,13 +73,13 @@ const git = async (
   args: readonly string[],
 ): Promise<string> => {
   const result = await runGit(context, directory, args).catch((error: unknown) => {
-    throw new Error(`Ohne paths braucht ${tool} ein Git-Arbeitsverzeichnis: ${messageOf(error)}`);
+    throw new Error(`Without paths ${tool} needs a Git working directory: ${messageOf(error)}`);
   });
-  if (result.code !== 0) throw new Error(`Ohne paths braucht ${tool} ein Git-Arbeitsverzeichnis (git ${args[0]}: Code ${result.code})`);
+  if (result.code !== 0) throw new Error(`Without paths ${tool} needs a Git working directory (git ${args[0]}: code ${result.code})`);
   return result.output;
 };
 
-/** Git nennt seine Pfade relativ zur Repo-Wurzel; `-- .` grenzt sie auf die Wurzel der Instanz ein. */
+/** Git names its paths relative to the repo root; `-- .` narrows them to the root of the instance. */
 export const changedWorkspaceFiles = async (
   context: WorkspaceProcessContext,
   directory: string,
@@ -130,11 +130,11 @@ export class LanguageServerHost {
     return this.adapter.languages[path.extname(filePath).toLowerCase()] !== undefined;
   }
 
-  /** Mit `ifNoneOpen` prüft und belegt der Aufruf den Run ohne Unterbrechung: läuft schon ein Öffnen oder ist eine Instanz da, lädt er nichts. */
+  /** With `ifNoneOpen` the call checks and claims the run without interruption: if an open is already running or an instance exists, it loads nothing. */
   async open(runId: string, root: string, ifNoneOpen = false): Promise<string> {
     const lifetime = this.#lifetime(runId);
     if (ifNoneOpen && !this.#idle(runId)) {
-      return `${this.adapter.label} lädt ${root} nicht: in diesem Run ist schon eine Instanz offen oder im Aufbau`;
+      return `${this.adapter.label} does not load ${root}: an instance is already open or starting in this run`;
     }
     this.#requests.set(runId, (this.#requests.get(runId) ?? 0) + 1);
     try {
@@ -148,7 +148,7 @@ export class LanguageServerHost {
 
   async solutions(runId: string): Promise<LanguageServerSolutions> {
     const extensions = this.adapter.solutionExtensions;
-    if (!extensions) throw new Error(`${this.adapter.label} sucht keine Solutions`);
+    if (!extensions) throw new Error(`${this.adapter.label} does not search for solutions`);
     if (this.#closed) throw this.#stopped();
     const found = await workspaceSolutions(await this.#contextFor(runId), extensions);
     return {
@@ -158,7 +158,7 @@ export class LanguageServerHost {
     };
   }
 
-  /** Lädt die Wurzel und beendet jede andere Instanz des Runs; wartet nicht auf das Laden, `null` beendet alle. */
+  /** Loads the root and ends every other instance of the run; does not wait for the loading, `null` ends all. */
   async switchTo(runId: string, root: string | null): Promise<string> {
     if (root === null) return this.close(runId);
     const lifetime = this.#lifetime(runId);
@@ -168,10 +168,10 @@ export class LanguageServerHost {
     this.#assertLifetime(runId, lifetime);
     const current = this.#current(runId, absoluteRoot);
     const kept = current !== undefined && current.state !== "failed";
-    // Ein Fehlschlag steht mit seiner Ursache im Stand der Instanz.
+    // A failure is recorded with its cause in the state of the instance.
     if (!kept) void this.#start(runId, context, absoluteRoot).catch(() => undefined);
-    const closed = others.length === 0 ? "" : `; ${others.length === 1 ? "eine andere Instanz" : `${others.length} andere Instanzen`} beendet`;
-    return `${this.adapter.label} ${kept ? "behält" : "lädt"} ${absoluteRoot}${closed}`;
+    const closed = others.length === 0 ? "" : `; ${others.length === 1 ? "one other instance" : `${others.length} other instances`} ended`;
+    return `${this.adapter.label} ${kept ? "keeps" : "loads"} ${absoluteRoot}${closed}`;
   }
 
   async #open(runId: string, lifetime: object, root: string): Promise<string> {
@@ -184,26 +184,26 @@ export class LanguageServerHost {
       });
       this.#assertCurrent(current);
       this.#touch(runId, absoluteRoot);
-      return this.#openMessage(runId, `${this.adapter.label} ist für ${absoluteRoot} bereits geöffnet: ${server.summary}`);
+      return this.#openMessage(runId, `${this.adapter.label} is already open for ${absoluteRoot}: ${server.summary}`);
     }
     const server = await this.#start(runId, context, absoluteRoot);
     this.#assertLifetime(runId, lifetime);
     if (this.#servers.get(keyOf(runId, absoluteRoot))?.server !== server) throw this.#stopped();
-    return this.#openMessage(runId, `${server.summary} (Wurzel ${absoluteRoot})`);
+    return this.#openMessage(runId, `${server.summary} (root ${absoluteRoot})`);
   }
 
   async close(runId: string, root?: string): Promise<string> {
     if (root === undefined) {
       const roots = this.#openRoots(runId);
-      if (roots.length === 0) return `${this.adapter.label} ist in diesem Run nicht geöffnet`;
+      if (roots.length === 0) return `${this.adapter.label} is not open in this run`;
       await Promise.all(roots.map((entry) => this.#closeInstance(runId, entry)));
-      const closed = roots.length === 1 ? "eine Instanz" : `${roots.length} Instanzen`;
-      return `${this.adapter.label}: ${closed} beendet; keine offene Instanz mehr in diesem Run`;
+      const closed = roots.length === 1 ? "one instance" : `${roots.length} instances`;
+      return `${this.adapter.label}: ${closed} ended; no open instance left in this run`;
     }
     const context = await this.#contextFor(runId);
     const chosen = await this.#known(runId, context, root);
     await this.#closeInstance(runId, chosen);
-    return `${this.adapter.label} für ${chosen} beendet; ${instanceCount(this.#openRoots(runId).length)} in diesem Run`;
+    return `${this.adapter.label} for ${chosen} ended; ${instanceCount(this.#openRoots(runId).length)} in this run`;
   }
 
   async snapshot(runId: string): Promise<LanguageServerSnapshot> {
@@ -225,14 +225,14 @@ export class LanguageServerHost {
     const context = await this.#contextFor(runId);
     this.#assertLifetime(runId, lifetime);
     const roots = root === undefined ? this.#openRoots(runId) : [await this.#known(runId, context, root)];
-    if (roots.length === 0) throw new Error(`Kein ${this.adapter.label}-Server geöffnet; zuerst ${this.adapter.id}_open aufrufen`);
+    if (roots.length === 0) throw new Error(`No ${this.adapter.label} server open; call ${this.adapter.id}_open first`);
     if (paths !== undefined && paths.length > 0) return (await this.#requested(runId, context, roots, paths, includeWarnings)).join("\n\n");
     const failed = root === undefined ? roots.filter((entry) => this.#current(runId, entry)?.state === "failed") : [];
     const failures = failed.map((entry) =>
-      `${this.adapter.label} für ${entry} nicht geöffnet: ${this.#current(runId, entry)!.summary}; ${this.adapter.id}_open öffnet die Wurzel erneut`);
+      `${this.adapter.label} not open for ${entry}: ${this.#current(runId, entry)!.summary}; ${this.adapter.id}_open opens the root again`);
     if (failed.length === roots.length) throw new Error(failures.join("\n"));
     const results = await this.#changed(runId, context, roots.filter((entry) => !failed.includes(entry)), includeWarnings);
-    const text = results.length === 0 ? `Keine geänderten ${this.adapter.label}-Dateien in den geöffneten Wurzeln` : results.join("\n\n");
+    const text = results.length === 0 ? `No changed ${this.adapter.label} files in the open roots` : results.join("\n\n");
     return [text, ...failures].join("\n\n");
   }
 
@@ -248,7 +248,7 @@ export class LanguageServerHost {
       const server = await this.#ensure(runId, context, chosen);
       return await this.#format(context, server, file, false);
     } catch (error) {
-      return `Diagnostik (${this.adapter.label}) fehlgeschlagen: ${messageOf(error)}`;
+      return `Diagnostics (${this.adapter.label}) failed: ${messageOf(error)}`;
     }
   }
 
@@ -276,7 +276,7 @@ export class LanguageServerHost {
     const failures = results
       .filter((result): result is PromiseRejectedResult => result.status === "rejected")
       .map((result) => result.reason);
-    if (failures.length > 0) throw new AggregateError(failures, `${this.adapter.label}-Shutdown fehlgeschlagen`);
+    if (failures.length > 0) throw new AggregateError(failures, `${this.adapter.label} shutdown failed`);
   }
 
   async #prepare(
@@ -320,7 +320,7 @@ export class LanguageServerHost {
   }
 
   #openMessage(runId: string, text: string): string {
-    return `${text}; ${instanceCount(this.#openRoots(runId).length)} von ${this.adapter.label} in diesem Run`;
+    return `${text}; ${instanceCount(this.#openRoots(runId).length)} of ${this.adapter.label} in this run`;
   }
 
   async #instanceSnapshot(runId: string, root: string): Promise<LanguageServerInstanceSnapshot | undefined> {
@@ -385,11 +385,11 @@ export class LanguageServerHost {
     for (const requested of paths) {
       const file = await allowedWorkspacePath(path.resolve(context.root, expandWorkspaceAlias(requested, context.workspaceAliases ?? {})), [context.root, ...context.additionalRoots ?? []]);
       if (!this.handles(file)) {
-        throw new Error(`${path.relative(context.root, file)} hat keine ${this.adapter.label}-Endung (${Object.keys(this.adapter.languages).join(", ")})`);
+        throw new Error(`${path.relative(context.root, file)} has no ${this.adapter.label} extension (${Object.keys(this.adapter.languages).join(", ")})`);
       }
       const chosen = this.#match(roots, file);
       if (!chosen) {
-        throw new Error(`${path.relative(context.root, file)} liegt in keiner geöffneten ${this.adapter.label}-Wurzel; offen: ${roots.join(", ")}`);
+        throw new Error(`${path.relative(context.root, file)} is in no open ${this.adapter.label} root; open: ${roots.join(", ")}`);
       }
       results.push(await this.#format(context, await this.#ensure(runId, context, chosen), file, includeWarnings));
     }
@@ -404,11 +404,11 @@ export class LanguageServerHost {
 
   async #known(runId: string, context: WorkspaceProcessContext, root: string): Promise<string> {
     const roots = this.#openRoots(runId);
-    if (roots.length === 0) throw new Error(`Kein ${this.adapter.label}-Server geöffnet; zuerst ${this.adapter.id}_open aufrufen`);
+    if (roots.length === 0) throw new Error(`No ${this.adapter.label} server open; call ${this.adapter.id}_open first`);
     const lexical = path.resolve(context.root, expandWorkspaceAlias(root, context.workspaceAliases ?? {}));
     const requested = await resolvedWorkspacePath(lexical);
     const found = roots.find((open) => open === requested || open === lexical);
-    if (!found) throw new Error(`Für ${root} ist kein ${this.adapter.label}-Server geöffnet; offen: ${roots.join(", ")}`);
+    if (!found) throw new Error(`No ${this.adapter.label} server is open for ${root}; open: ${roots.join(", ")}`);
     return found;
   }
 
@@ -465,7 +465,7 @@ export class LanguageServerHost {
     const current = this.#servers.get(key);
     if (current?.server?.session.exited) {
       this.#servers.delete(key);
-      void this.#dispose(current).catch((error) => console.error(`${this.adapter.label}: Bereinigung fehlgeschlagen: ${messageOf(error)}`));
+      void this.#dispose(current).catch((error) => console.error(`${this.adapter.label}: cleanup failed: ${messageOf(error)}`));
       return undefined;
     }
     return current;
@@ -488,7 +488,7 @@ export class LanguageServerHost {
     const previous = this.#servers.get(key);
     const closing = previous ? this.#dispose(previous) : undefined;
     const entry: ServerEntry = {
-      runId, root, state: "opening", summary: `${this.adapter.label} lädt ${root}`, controller: new AbortController(),
+      runId, root, state: "opening", summary: `${this.adapter.label} loads ${root}`, controller: new AbortController(),
     };
     this.#servers.set(key, entry);
     this.#remember(runId, root);
@@ -513,13 +513,13 @@ export class LanguageServerHost {
           summary = await withTimeout(
             Promise.race([this.adapter.open(session, root, this.#openTimeoutMs), cancelled]),
             this.#openTimeoutMs,
-            () => new Error(`${this.adapter.label}: ${root} nicht innerhalb von ${Math.round(this.#openTimeoutMs / 1000)} s geladen`),
+            () => new Error(`${this.adapter.label}: ${root} not loaded within ${Math.round(this.#openTimeoutMs / 1000)} s`),
           );
         } finally {
           entry.controller.signal.removeEventListener("abort", aborted);
         }
         this.#assertCurrent(entry);
-        if (session.exited) throw new Error(`${this.adapter.label} wurde während des Ladens beendet`);
+        if (session.exited) throw new Error(`${this.adapter.label} ended while loading`);
         const server = { root, session, summary };
         entry.server = server;
         entry.state = "ready";
@@ -585,7 +585,7 @@ export class LanguageServerHost {
   }
 
   #stopped(): Error {
-    return new Error(`${this.adapter.label}-Start wurde beendet`);
+    return new Error(`${this.adapter.label} start was ended`);
   }
 
   #touch(runId: string, root: string): void {
@@ -597,7 +597,7 @@ export class LanguageServerHost {
     const timer = setTimeout(() => {
       this.#idleTimers.delete(key);
       if (this.#servers.get(key) !== entry) return;
-      void this.#close(key).catch((error) => console.error(`${this.adapter.label}: Beenden nach Leerlauf fehlgeschlagen: ${messageOf(error)}`));
+      void this.#close(key).catch((error) => console.error(`${this.adapter.label}: ending after idle time failed: ${messageOf(error)}`));
     }, this.#idleMs);
     timer.unref();
     this.#idleTimers.set(key, timer);

package/packages/workspace-executor/src/language-server/json-rpc.ts

@@ -45,13 +45,13 @@ export class JsonRpcConnection {
     this.#connection.onNotification("$/progress", (params) => options.onNotification("$/progress", params));
     this.#connection.onNotification("$/logTrace", (params) => options.onNotification("$/logTrace", params));
     this.#connection.onError(([error]) => this.#fail(error));
-    this.#connection.onClose(() => this.#fail(new Error("Verbindung geschlossen")));
+    this.#connection.onClose(() => this.#fail(new Error("Connection closed")));
     this.#connection.listen();
   }
 
   async request(method: string, params: unknown, signal?: AbortSignal): Promise<unknown> {
     if (this.#closed) throw this.#closed;
-    const abortError = () => signal?.reason instanceof Error ? signal.reason : new Error(`${method} wurde abgebrochen`);
+    const abortError = () => signal?.reason instanceof Error ? signal.reason : new Error(`${method} was cancelled`);
     if (signal?.aborted) throw abortError();
     const parameters = params === null || params === undefined ? [] : [params];
     const cancellation = new CancellationTokenSource();
@@ -68,7 +68,7 @@ export class JsonRpcConnection {
           else if (error instanceof ResponseError) {
             reject(new ResponseError(
               error.code,
-              `${this.#options.label}: ${method} fehlgeschlagen: ${error.message}`,
+              `${this.#options.label}: ${method} failed: ${error.message}`,
               error.data,
             ));
           } else reject(error);
@@ -96,7 +96,7 @@ export class JsonRpcConnection {
 
   #fail(error: Error): void {
     if (this.#closed) return;
-    const failure = new Error(`${this.#options.label}: JSON-RPC-Verbindung fehlgeschlagen: ${error.message}`, { cause: error });
+    const failure = new Error(`${this.#options.label}: JSON-RPC connection failed: ${error.message}`, { cause: error });
     this.close(failure);
     this.#options.onError(failure);
   }

package/packages/workspace-executor/src/language-server/module.ts

@@ -28,13 +28,13 @@ const invalid = (operation: string, message: string): WorkspaceOperationError =>
 
 const fieldsOf = (operation: string, input: unknown): Readonly<Record<string, unknown>> => {
   const fields = input ?? {};
-  if (typeof fields !== "object" || Array.isArray(fields)) throw invalid(operation, "Die Eingabe muss ein Objekt sein");
+  if (typeof fields !== "object" || Array.isArray(fields)) throw invalid(operation, "The input must be an object");
   return fields as Readonly<Record<string, unknown>>;
 };
 
 const optionalRoot = (operation: string, value: unknown): string | undefined => {
   if (value === undefined) return undefined;
-  if (typeof value !== "string") throw invalid(operation, "root muss ein Text sein");
+  if (typeof value !== "string") throw invalid(operation, "root must be a text");
   return value;
 };
 
@@ -44,7 +44,7 @@ const solutionOperationsOf = (server: LanguageServerHost): Array<readonly [strin
     [languageServerSolutionsOperation(server.adapter.id), ({ runId }) => server.solutions(runId)],
     [change, ({ runId, input }) => {
       const { root } = fieldsOf(change, input);
-      if (root !== null && typeof root !== "string") throw invalid(change, "root muss ein Text oder null sein");
+      if (root !== null && typeof root !== "string") throw invalid(change, "root must be a text or null");
       return server.switchTo(runId, root);
     }],
   ];
@@ -59,15 +59,15 @@ const operationsOf = (server: LanguageServerHost): Array<readonly [string, Works
     [open, ({ runId, input }) => {
       const { root, ifNoneOpen } = fieldsOf(open, input);
       const checked = optionalRoot(open, root);
-      if (checked === undefined) throw invalid(open, "root fehlt");
-      if (ifNoneOpen !== undefined && typeof ifNoneOpen !== "boolean") throw invalid(open, "ifNoneOpen muss true oder false sein");
+      if (checked === undefined) throw invalid(open, "root is missing");
+      if (ifNoneOpen !== undefined && typeof ifNoneOpen !== "boolean") throw invalid(open, "ifNoneOpen must be true or false");
       return server.open(runId, checked, ifNoneOpen ?? false);
     }],
     [close, ({ runId, input }) => server.close(runId, optionalRoot(close, fieldsOf(close, input).root))],
     [diagnostics, ({ runId, input }) => {
       const { paths, warnings, root } = fieldsOf(diagnostics, input);
-      if (paths !== undefined && (!Array.isArray(paths) || !paths.every((entry) => typeof entry === "string"))) throw invalid(diagnostics, "paths muss eine Liste von Texten sein");
-      if (warnings !== undefined && typeof warnings !== "boolean") throw invalid(diagnostics, "warnings muss true oder false sein");
+      if (paths !== undefined && (!Array.isArray(paths) || !paths.every((entry) => typeof entry === "string"))) throw invalid(diagnostics, "paths must be a list of texts");
+      if (warnings !== undefined && typeof warnings !== "boolean") throw invalid(diagnostics, "warnings must be true or false");
       return server.diagnostics(runId, paths as readonly string[] | undefined, warnings ?? false, optionalRoot(diagnostics, root));
     }],
     [languageServerSnapshotOperation(id), ({ runId }) => server.snapshot(runId)],
@@ -75,7 +75,7 @@ const operationsOf = (server: LanguageServerHost): Array<readonly [string, Works
   ];
 };
 
-/** Öffnen und Schließen sprechen die Wurzel ihrer Instanz an, die Diagnostik dazu die ihrer Dateien; ohne Wurzel und Dateien keine bestimmte. */
+/** Open and close address the root of their instance, diagnostics also the roots of its files; without root and files no specific one. */
 const footprintsOf = (server: LanguageServerHost): Array<readonly [string, (input: unknown) => OperationFootprint]> => {
   const { id } = server.adapter;
   return [
@@ -85,13 +85,13 @@ const footprintsOf = (server: LanguageServerHost): Array<readonly [string, (inpu
   ];
 };
 
-/** Die Sprachserver dieser Maschine: je Adapter Öffnen, Diagnostik, Schließen und Stand, mit Solutions auch Suche und Umschalten, dazu die Diagnostik geschriebener Dateien. */
+/** The language servers of this machine: per adapter open, diagnostics, close and state, with solutions also search and switching, plus the diagnostics of written files. */
 export const languageServerModule = (
   adapters: readonly LanguageServerAdapter[],
   options: LanguageServerHostOptions = {},
 ): WorkspaceModuleFactory => {
   const duplicate = adapters.find((adapter, index) => adapters.findIndex((other) => other.id === adapter.id) !== index);
-  if (duplicate) throw new Error(`Der Sprachserver ${duplicate.id} kommt im Executor zweimal vor; seine Operationen gehören genau einem Beitrag`);
+  if (duplicate) throw new Error(`The language server ${duplicate.id} occurs twice in the executor; its operations belong to exactly one contribution`);
   return (host) => languageServersOn(host, adapters, options);
 };
 
@@ -107,7 +107,7 @@ const languageServersOn = (
     annotate: async (runId, absolutePath) => {
       const notes = await Promise.all(servers.map((server) =>
         server.annotate(runId, absolutePath).catch((error: unknown) =>
-          `Diagnostik (${server.adapter.label}) fehlgeschlagen: ${messageOf(error)}`)));
+          `Diagnostics (${server.adapter.label}) failed: ${messageOf(error)}`)));
       const text = notes.filter((note): note is string => Boolean(note)).join("\n");
       return text || undefined;
     },

package/packages/workspace-executor/src/language-server/roots.ts

@@ -9,16 +9,16 @@ export const resolveRootFile = async (
 ): Promise<string> => {
   const absolute = await allowedWorkspacePath(path.resolve(workspaceRoot, requested), [workspaceRoot]);
   if (!extensions.includes(path.extname(absolute).toLowerCase())) {
-    throw new Error(`${requested} hat keine der Endungen ${extensions.join(", ")}`);
+    throw new Error(`${requested} has none of the extensions ${extensions.join(", ")}`);
   }
   const info = await stat(absolute).catch(() => undefined);
-  if (!info?.isFile()) throw new Error(`${requested} gibt es im Arbeitsverzeichnis nicht`);
+  if (!info?.isFile()) throw new Error(`${requested} does not exist in the working directory`);
   return absolute;
 };
 
 export const resolveRootDirectory = async (workspaceRoot: string, requested: string): Promise<string> => {
   const absolute = await allowedWorkspacePath(path.resolve(workspaceRoot, requested), [workspaceRoot]);
   const info = await stat(absolute).catch(() => undefined);
-  if (!info?.isDirectory()) throw new Error(`${requested} ist kein Verzeichnis im Arbeitsverzeichnis`);
+  if (!info?.isDirectory()) throw new Error(`${requested} is not a directory in the working directory`);
   return absolute;
 };