@hydranium/cli 1.0.0-next.38 → 1.0.0-next.380

package/src/commands/delete.ts

@@ -0,0 +1,61 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+import type { TransferElement } from '@hydranium/protocol';
+import type { DataServerProtocol } from '@hydranium/protocol/data';
+import { logEnv, type LogOptions } from '../log-level.js';
+import { withDataServer } from '../spawn-data-server.js';
+import { withClientSession } from './client-session.js';
+
+/**
+ * Options for the {@link runDelete} subcommand. Deletes the document at `uri`,
+ * its file and then the document, via the data-server's `deleteModelDocument`
+ * RPC, whatever text it holds. Prints nothing; a failed delete rejects.
+ *
+ * `clientId` defaults to `'hydranium-cli'`. The command deletes as a client
+ * session under it: it registers the session, opens the document, deletes it,
+ * and ends the session.
+ */
+export interface DeleteCommandOptions extends LogOptions {
+   readonly serverCommand: string;
+   readonly serverArgs?: readonly string[];
+   readonly cwd?: string;
+   readonly uri: string;
+   readonly clientId?: string;
+   readonly __proxyForTest?: DataServerProtocol<TransferElement>;
+}
+
+export async function runDelete(options: DeleteCommandOptions): Promise<void> {
+   const clientId = options.clientId ?? 'hydranium-cli';
+   if (options.__proxyForTest) {
+      await deleteOpened(options.__proxyForTest, options.uri, clientId);
+      return;
+   }
+   await withDataServer(
+      {
+         command: options.serverCommand,
+         args: options.serverArgs,
+         cwd: options.cwd,
+         env: logEnv(options)
+      },
+      server => deleteOpened(server, options.uri, clientId)
+   );
+}
+
+/** Open `uri` as the session `clientId` and delete it, then end the session. */
+function deleteOpened(
+   server: Pick<DataServerProtocol<TransferElement>, 'createSession' | 'openModelDocument' | 'deleteModelDocument' | 'closeSession'>,
+   uri: string,
+   clientId: string
+): Promise<void> {
+   return withClientSession(server, clientId, async () => {
+      await server.openModelDocument({ uri, clientId });
+      await server.deleteModelDocument({ uri, clientId, baseVersion: 'any' });
+   });
+}

package/src/commands/generate-ast-builder.ts

@@ -10,6 +10,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import type { SourceFile } from 'ts-morph';
+import { relativeImportPath } from './generated-module-path.js';
 
 /** Inputs for {@link emitAstBuilder}, resolved by the transfer-model command. */
 export interface EmitAstBuilderOptions {
@@ -175,17 +176,6 @@ function findReflectionConstName(astSource: SourceFile, languageId: string): str
    return 'reflection';
 }
 
-/**
- * Module specifier for the AST file as seen from the generated module's own
- * directory. Emitted with a `.js` extension and posix separators because the
- * output is ESM TypeScript, where the specifier names the compiled sibling.
- */
-function relativeImportPath(outFile: string, astFile: string): string {
-   const relative = path.relative(path.dirname(path.resolve(outFile)), path.resolve(astFile));
-   const posix = relative.split(path.sep).join('/').replace(/\.ts$/, '.js');
-   return posix.startsWith('.') ? posix : `./${posix}`;
-}
-
 function renderAstBuilder(
    bindings: readonly BuilderBinding[],
    context: { reflectionName: string; importPath: string; regenCommand: string }

package/src/commands/generate-languages.ts

@@ -0,0 +1,132 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { kebab } from './kebab.js';
+import { type Expression, type ObjectLiteralExpression, type SourceFile, SyntaxKind } from 'ts-morph';
+
+/** Inputs for {@link emitLanguages}, resolved by the transfer-model command. */
+export interface EmitLanguagesOptions {
+   /** Destination path for the generated languages module. */
+   outFile: string;
+   /** Header line naming the command that regenerates the file. */
+   regenCommand: string;
+}
+
+interface LanguageEntry {
+   constName: string;
+   languageId: string;
+   fileExtensions: string[];
+}
+
+/** Suffix langium-cli gives each grammar's metadata const in `module.ts`. */
+const METADATA_SUFFIX = 'LanguageMetaData';
+
+/**
+ * Emit a module stating each grammar's language id and file extensions for a
+ * package a client can depend on.
+ *
+ * Read from the `<Grammar>LanguageMetaData` consts langium-cli writes into
+ * `module.ts`, which is the only place the ids exist outside `langium-config.json`
+ * and which a client cannot import, since it pulls in Langium. Generating the
+ * copy instead of writing it by hand is what keeps every host's id list in step
+ * with the grammars.
+ */
+export function emitLanguages(moduleSource: SourceFile, options: EmitLanguagesOptions): void {
+   const content = buildLanguagesSource(moduleSource, options);
+   fs.mkdirSync(path.dirname(options.outFile), { recursive: true });
+   if (fs.existsSync(options.outFile) && fs.readFileSync(options.outFile, 'utf-8') === content) {
+      console.log('Languages module is up to date.');
+      return;
+   }
+   fs.writeFileSync(options.outFile, content, 'utf-8');
+   console.log(`Generated: ${options.outFile}`);
+}
+
+/**
+ * The module text {@link emitLanguages} would write. Pure over its inputs, so
+ * the emitted shape is testable without touching a filesystem. Throws when the
+ * source declares no metadata, since an empty list would make every host
+ * register nothing without an error.
+ */
+export function buildLanguagesSource(moduleSource: SourceFile, options: Pick<EmitLanguagesOptions, 'regenCommand'>): string {
+   const entries: LanguageEntry[] = [];
+   const grammarsByConst = new Map<string, string>();
+   for (const declaration of moduleSource.getVariableDeclarations()) {
+      const name = declaration.getName();
+      if (!name.endsWith(METADATA_SUFFIX)) {
+         continue;
+      }
+      const literal = objectLiteralOf(declaration.getInitializer());
+      const grammar = name.slice(0, -METADATA_SUFFIX.length);
+      const constName = `${kebab(grammar).replace(/-/g, '_').toUpperCase()}_LANGUAGE`;
+      const clash = grammarsByConst.get(constName);
+      if (clash !== undefined) {
+         throw new Error(
+            `Cannot emit the languages module: grammars '${clash}' and '${grammar}' both map to '${constName}'. ` +
+               'Rename one grammar so the generated constants stay distinct.'
+         );
+      }
+      grammarsByConst.set(constName, grammar);
+      entries.push({
+         constName,
+         languageId: stringProperty(literal, name, 'languageId'),
+         fileExtensions: stringArrayProperty(literal, name, 'fileExtensions')
+      });
+   }
+   if (entries.length === 0) {
+      throw new Error(`Cannot emit the languages module: ${moduleSource.getFilePath()} declares no '<Grammar>${METADATA_SUFFIX}'.`);
+   }
+
+   const out: string[] = [];
+   out.push('/******************************************************************************');
+   out.push(' * Generated from the Langium language metadata — DO NOT EDIT MANUALLY!');
+   out.push(` * ${options.regenCommand}`);
+   out.push(' ******************************************************************************/');
+   out.push('');
+   for (const entry of entries) {
+      const extensions = entry.fileExtensions.map(extension => JSON.stringify(extension)).join(', ');
+      out.push(
+         `export const ${entry.constName} = { languageId: ${JSON.stringify(entry.languageId)}, fileExtensions: [${extensions}] } as const;`
+      );
+   }
+   out.push('');
+   out.push('/** Every language of the project, in the order langium-cli declares them. */');
+   out.push(`export const ALL_LANGUAGES = [${entries.map(entry => entry.constName).join(', ')}] as const;`);
+   return out.join('\n') + '\n';
+}
+
+/** The object literal under `as const` / `satisfies` wrappers, which langium-cli adds. */
+function objectLiteralOf(initializer: Expression | undefined): ObjectLiteralExpression | undefined {
+   return (
+      initializer?.asKind(SyntaxKind.ObjectLiteralExpression) ?? initializer?.getFirstDescendantByKind(SyntaxKind.ObjectLiteralExpression)
+   );
+}
+
+function stringProperty(literal: ObjectLiteralExpression | undefined, owner: string, key: string): string {
+   const value = literal?.getProperty(key)?.asKind(SyntaxKind.PropertyAssignment)?.getInitializer()?.asKind(SyntaxKind.StringLiteral);
+   if (value === undefined) {
+      throw new Error(`Cannot emit the languages module: ${owner} has no string '${key}'.`);
+   }
+   return value.getLiteralValue();
+}
+
+function stringArrayProperty(literal: ObjectLiteralExpression | undefined, owner: string, key: string): string[] {
+   const array = literal
+      ?.getProperty(key)
+      ?.asKind(SyntaxKind.PropertyAssignment)
+      ?.getInitializer()
+      ?.asKind(SyntaxKind.ArrayLiteralExpression);
+   const values = array?.getElements().map(element => element.asKind(SyntaxKind.StringLiteral)?.getLiteralValue());
+   if (values === undefined || !values.every((value): value is string => value !== undefined)) {
+      throw new Error(`Cannot emit the languages module: ${owner} has no string array '${key}'.`);
+   }
+   return values;
+}

package/src/commands/generate-transfer-builder.ts

@@ -0,0 +1,101 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { describeError } from '@hydranium/protocol';
+import { relativeImportPath } from './generated-module-path.js';
+
+/** Inputs for {@link emitTransferBuilder}, resolved by the transfer-model command. */
+export interface EmitTransferBuilderOptions {
+   /** Destination path for the generated builder module. */
+   outFile: string;
+   /** Path of the generated transfer model the builder binds to. */
+   transferModelFile: string;
+   /** Language id derived from the `<LanguageId>AstReflection` class name. */
+   languageId: string;
+   /** Header line naming the command that regenerates the file. */
+   regenCommand: string;
+}
+
+/**
+ * Emit a test module binding `makeTransferNodeBuilder` to the transfer model's
+ * reflection and type map, as `transferNode`.
+ *
+ * The module usually sits in a test tree of the server package while the
+ * transfer model sits in a protocol package of its own, and a relative import
+ * would reach into that package's sources. Across packages it therefore imports
+ * the model by the package's name, which relies on the package's main entry
+ * re-exporting the generated model; within one package it imports by path.
+ */
+export function emitTransferBuilder(options: EmitTransferBuilderOptions): void {
+   const content = buildTransferBuilderSource(options);
+   fs.mkdirSync(path.dirname(options.outFile), { recursive: true });
+   if (fs.existsSync(options.outFile) && fs.readFileSync(options.outFile, 'utf-8') === content) {
+      console.log('Transfer builder is up to date.');
+      return;
+   }
+   fs.writeFileSync(options.outFile, content, 'utf-8');
+   console.log(`Generated: ${options.outFile}`);
+}
+
+/** The module text {@link emitTransferBuilder} would write. */
+export function buildTransferBuilderSource(options: EmitTransferBuilderOptions): string {
+   const modelPackage = owningPackage(options.transferModelFile);
+   const specifier =
+      modelPackage !== undefined && modelPackage.dir !== owningPackage(options.outFile)?.dir
+         ? modelPackage.name
+         : relativeImportPath(options.outFile, options.transferModelFile);
+   const reflection = `${options.languageId}TransferReflection`;
+   const typeMap = `${options.languageId}TransferTypes`;
+   return [
+      '/******************************************************************************',
+      ' * Generated from the Langium AST — DO NOT EDIT MANUALLY!',
+      ` * ${options.regenCommand}`,
+      ' ******************************************************************************/',
+      '',
+      '/* eslint-disable */',
+      '',
+      "import { makeTransferNodeBuilder } from '@hydranium/protocol/testing';",
+      `import { ${reflection}, type ${typeMap} } from '${specifier}';`,
+      '',
+      '/**',
+      " * Transfer-node factory for this project's grammar, for tests. It fills the",
+      ' * grammar defaults, so a test names only the fields it cares about;',
+      ' * `transferNode.partial` fills none and types the node as incomplete.',
+      ' */',
+      `export const transferNode = makeTransferNodeBuilder<${typeMap}, typeof ${reflection}>(${reflection});`,
+      ''
+   ].join('\n');
+}
+
+/** The nearest `package.json` at or above `file` that names a package. */
+function owningPackage(file: string): { dir: string; name: string } | undefined {
+   let dir = path.dirname(path.resolve(file));
+   for (;;) {
+      const manifest = path.join(dir, 'package.json');
+      if (fs.existsSync(manifest)) {
+         let parsed: unknown;
+         try {
+            parsed = JSON.parse(fs.readFileSync(manifest, 'utf-8'));
+         } catch (error: unknown) {
+            throw new Error(`Cannot read '${manifest}' to name the transfer model's package: ${describeError(error)}`);
+         }
+         const name = typeof parsed === 'object' && parsed !== null && 'name' in parsed ? parsed.name : undefined;
+         if (typeof name === 'string') {
+            return { dir, name };
+         }
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) {
+         return undefined;
+      }
+      dir = parent;
+   }
+}

package/src/commands/generate-transfer-model-args.ts

@@ -30,6 +30,8 @@ export const GENERATE_TRANSFER_MODEL_FLAGS: readonly string[] = [
    '--augmentation-file',
    '--out-file',
    '--ast-builder-file',
+   '--transfer-builder-file',
+   '--languages-file',
    '--element-type-name',
    '--terminals-name',
    '--terminals-source-name',
@@ -50,11 +52,12 @@ export const GENERATE_TRANSFER_MODEL_HELP: readonly string[] = [
    'Usage: hydranium-cli generate-transfer-model [options]',
    '',
    'Generate a serializable transfer-model TypeScript file from a Langium AST, and',
-   'optionally an AST-node builder module bound to the same reflection. The',
-   'required inputs (--ast-file / --augmentation-file / --out-file) may instead come',
-   'from a --config JSON file, and --ast-file can be auto-discovered from a Langium',
-   "config's `out` directory. Precedence, highest first: explicit flags, then the",
-   '--config file, then the langium-config-derived --ast-file.',
+   'optionally an AST-node builder bound to the same reflection and a transfer-node',
+   'builder for tests. The required inputs (--ast-file / --augmentation-file /',
+   '--out-file) may instead come from a --config JSON file, and --ast-file can be',
+   "auto-discovered from a Langium config's `out` directory. Precedence, highest",
+   'first: explicit flags, then the --config file, then the langium-config-derived',
+   '--ast-file.',
    '',
    'Options:',
    '  --config <path>               JSON config supplying any of the options below.',
@@ -74,6 +77,12 @@ export const GENERATE_TRANSFER_MODEL_HELP: readonly string[] = [
    '                                spanning all of them. Omit if nothing constructs',
    '                                AST nodes. Same restriction as --out-file: keep it',
    "                                out of langium-cli's own `out` directory.",
+   '  --transfer-builder-file <p>   Also emit a test module here binding',
+   '                                makeTransferNodeBuilder to the transfer model as',
+   '                                transferNode. Import it from tests only.',
+   "  --languages-file <path>       Also emit each grammar's language id and file",
+   '                                extensions here, read from the module.ts beside',
+   '                                --ast-file, for a package without Langium.',
    '  --element-type-name <name>    Base element type name in output. Default: TransferElement.',
    '  --terminals-name <name>       Terminals const name in output. Default: ModelTerminals.',
    '  --terminals-source-name <n>   Source-side terminals variable name. Default: <LanguageId>Terminals.',
@@ -130,6 +139,12 @@ export function parseGenerateOptions(args: string[], onError: UsageError = exitW
          case '--ast-builder-file':
             flags.astBuilderFile = next();
             break;
+         case '--transfer-builder-file':
+            flags.transferBuilderFile = next();
+            break;
+         case '--languages-file':
+            flags.languagesFile = next();
+            break;
          case '--element-type-name':
             flags.elementTypeName = next();
             break;

package/src/commands/generate-transfer-model-config.ts

@@ -9,10 +9,11 @@
 
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { describeError } from '@hydranium/protocol';
 import type { GenerateTransferModelOptions } from './generate-transfer-model.js';
 
 /** Path-valued option keys — resolved relative to a config/langium-config file's directory. */
-const PATH_KEYS = ['astFile', 'augmentationFile', 'outFile', 'astBuilderFile'] as const;
+const PATH_KEYS = ['astFile', 'augmentationFile', 'outFile', 'astBuilderFile', 'transferBuilderFile', 'languagesFile'] as const;
 
 /** Resolve `value` against `baseDir` when it is relative; absolute paths pass through. */
 function resolveAgainst(baseDir: string, value: string): string {
@@ -31,7 +32,7 @@ export function loadTransferModelConfig(configPath: string): Partial<GenerateTra
    try {
       raw = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
    } catch (error: unknown) {
-      throw new Error(`Cannot read transfer-model config '${configPath}': ${error instanceof Error ? error.message : String(error)}`);
+      throw new Error(`Cannot read transfer-model config '${configPath}': ${describeError(error)}`);
    }
    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
       throw new Error(`Transfer-model config '${configPath}' must be a JSON object.`);
@@ -44,6 +45,8 @@ export function loadTransferModelConfig(configPath: string): Partial<GenerateTra
       'augmentationFile',
       'outFile',
       'astBuilderFile',
+      'transferBuilderFile',
+      'languagesFile',
       'elementTypeName',
       'terminalsName',
       'terminalsSourceName',
@@ -75,7 +78,7 @@ export function deriveAstFileFromLangiumConfig(langiumConfigPath: string): strin
    try {
       raw = JSON.parse(fs.readFileSync(langiumConfigPath, 'utf-8'));
    } catch (error: unknown) {
-      throw new Error(`Cannot read langium-config '${langiumConfigPath}': ${error instanceof Error ? error.message : String(error)}`);
+      throw new Error(`Cannot read langium-config '${langiumConfigPath}': ${describeError(error)}`);
    }
    const out = (raw as { out?: unknown })?.out;
    if (typeof out !== 'string') {
@@ -120,6 +123,8 @@ export function mergeTransferModelOptions(...sources: Array<Partial<GenerateTran
       augmentationFile: augmentationFile!,
       outFile: outFile!,
       astBuilderFile: pick('astBuilderFile'),
+      transferBuilderFile: pick('transferBuilderFile'),
+      languagesFile: pick('languagesFile'),
       elementTypeName: pick('elementTypeName'),
       terminalsName: pick('terminalsName'),
       terminalsSourceName: pick('terminalsSourceName'),