@hydranium/cli 1.0.0-next.412 → 1.0.0-next.416

package/src/commands/check-skills-args.ts

@@ -0,0 +1,70 @@
+/********************************************************************************
+ * 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 path from 'node:path';
+import { exitWithUsage, helpRequested, printHelp } from './harness-args.js';
+import { checkSkills } from './skills.js';
+
+export const CHECK_SKILLS_HELP = [
+   'Usage: hydranium-cli check-skills [project-directory] [--from <directory>] [--skill <names>]',
+   '',
+   'Check declared compatibility of installed Hydranium and Langium skills.',
+   'Reads .agents/skills and .claude/skills in the project directory (default: cwd).',
+   'Checks every copy. Does not download, update, or execute skills.',
+   'Exits non-zero for incompatible, missing, malformed, or unverified skills.',
+   '',
+   '  --from <directory>   Resolve installed packages from this directory, relative',
+   '                       to the project. Default: the project directory.',
+   '                       Use the server package for workspace-local dependencies.',
+   '  --skill <names>      Check only these comma-separated skill names.',
+   '                       Default: hydranium-*. Use --skill langium to check upstream.',
+   '',
+   'A compatible result checks declared skill contracts,',
+   'not the accuracy of prose.',
+   'Upstream skills without Hydranium metadata are unverified.'
+];
+
+export function runCheckSkillsCommand(args: string[]): void {
+   if (helpRequested(args, ['--from', '--skill'])) {
+      printHelp(CHECK_SKILLS_HELP);
+      return;
+   }
+   let project: string | undefined;
+   let from: string | undefined;
+   let names: string[] | undefined;
+   for (let index = 0; index < args.length; index++) {
+      const argument = args[index];
+      if (argument === '--from' || argument === '--skill') {
+         const value = args[++index];
+         if (!value || value.startsWith('--')) {
+            exitWithUsage(`Missing value for ${argument}`);
+         }
+         if (argument === '--from') {
+            from = value;
+         } else {
+            names = value.split(',');
+            if (names.some(name => !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name))) {
+               exitWithUsage('Invalid skill name.');
+            }
+         }
+      } else if (argument.startsWith('-') || project !== undefined) {
+         exitWithUsage(`Unexpected argument: ${argument} (hydranium-cli check-skills --help)`);
+      } else {
+         project = argument;
+      }
+   }
+   const root = path.resolve(project ?? '.');
+   const results = checkSkills(root, path.resolve(root, from ?? '.'), names);
+   for (const result of results) {
+      console.log(`${result.status}: ${result.file}: ${result.detail}`);
+   }
+   if (results.some(result => result.status !== 'compatible')) {
+      process.exitCode = 1;
+   }
+}

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

@@ -48,7 +48,7 @@ const NAMESPACED_AST_TYPE_NAME = 'AstType';
 const MERGED_EXPORT_NAME = 'astNode';
 
 /**
- * Emit a module binding {@link makeAstNodeBuilder} to a project's reflection,
+ * Emit a module binding `makeAstNodeBuilder` to a project's reflection,
  * once per grammar plus once across all of them.
  *
  * **The binding is boilerplate with exactly one degree of freedom** — the type

package/src/commands/init-args.ts

@@ -26,12 +26,14 @@
  * association is gone.
  */
 
+import * as path from 'node:path';
 import { assertRequired, exitWithUsage, helpRequested, printHelp, type UsageError } from './harness-args.js';
-import { isNonEmptyDir, runInit, type InitHead } from './init.js';
+import { isNonEmptyDir, runInit, validateInitInstallation, type InitHead } from './init.js';
 import type { InitHost } from './init-hosts.js';
 import { createClackPrompt } from './init-prompt.js';
 import { runInitWizard } from './init-wizard.js';
 import { createNodeWorkspaceProbe, detectWorkspace } from './init-workspace.js';
+import { installSkills, offerSkills, parseSkillInstallation, SKILLS_INSTALLER } from './init-skills.js';
 
 /** One grammar as the command line collected it, before any derivation. */
 export interface ParsedInitGrammar {
@@ -46,6 +48,9 @@ export interface ParsedInitArgs {
    targetDir?: string;
    name?: string;
    force: boolean;
+   install: boolean;
+   skills?: string;
+   agents?: string;
    heads?: InitHead[];
    hosts?: InitHost[];
    monorepo: boolean;
@@ -66,6 +71,9 @@ export const INIT_FLAGS: readonly string[] = [
    '--heads',
    '--hosts',
    '--force',
+   '--install',
+   '--skills',
+   '--agents',
    '--monorepo',
    '--scope',
    '--public',
@@ -80,6 +88,8 @@ export const INIT_FLAGS: readonly string[] = [
  * The rest are presence-only.
  */
 export const INIT_VALUE_FLAGS: readonly string[] = [
+   '--skills',
+   '--agents',
    '--name',
    '--heads',
    '--hosts',
@@ -104,6 +114,9 @@ export function parseInitArgs(args: string[], onError: UsageError = exitWithUsag
    let targetDir: string | undefined;
    let name: string | undefined;
    let force = false;
+   let install = false;
+   let skills: string | undefined;
+   let agents: string | undefined;
    let heads: InitHead[] | undefined;
    let hosts: InitHost[] | undefined;
    let monorepo = false;
@@ -131,6 +144,12 @@ export function parseInitArgs(args: string[], onError: UsageError = exitWithUsag
          return current;
       };
       switch (flag) {
+         case '--skills':
+            skills = next();
+            break;
+         case '--agents':
+            agents = next();
+            break;
          case '--name':
             name = next();
             break;
@@ -160,6 +179,9 @@ export function parseInitArgs(args: string[], onError: UsageError = exitWithUsag
          case '--force':
             force = true;
             break;
+         case '--install':
+            install = true;
+            break;
          case '--monorepo':
             monorepo = true;
             break;
@@ -184,7 +206,7 @@ export function parseInitArgs(args: string[], onError: UsageError = exitWithUsag
             }
       }
    }
-   return { targetDir, name, force, heads, hosts, monorepo, scope, public: isPublic, grammars };
+   return { targetDir, name, force, install, skills, agents, heads, hosts, monorepo, scope, public: isPublic, grammars };
 }
 
 /**
@@ -197,7 +219,7 @@ export function parseInitArgs(args: string[], onError: UsageError = exitWithUsag
 export const INIT_HELP: readonly string[] = [
    'Usage: hydranium-cli init <target-dir> --name <Name> [--heads <list>]',
    '                            [--hosts <list>] [--force] [--monorepo]',
-   '                            [--scope <@scope>] [--public]',
+   '                            [--scope <@scope>] [--public] [--install]',
    '                            ( --grammar <Name> [--extensions <list>]',
    '                                              [--language-id <id>] [--diagram] )...',
    '',
@@ -210,12 +232,18 @@ export const INIT_HELP: readonly string[] = [
    'launch of the VS Code and Theia ones, and theia/ the Theia extension;',
    'workspace/ holds two starter model files per grammar. A standalone project',
    'also gets a root manifest naming the packages as npm workspaces.',
-   'Does NOT run `npm install` or `langium generate` — those are printed as next',
-   'steps. Refuses a non-empty directory without --force.',
+   'Stays offline unless --install or --skills is requested. With --install,',
+   'runs `npm install` after writing the scaffold. Building remains a next step.',
+   'Refuses a non-empty directory',
+   'without --force.',
    '',
    'Run it with no --name on a terminal to be prompted instead. The wizard echoes',
    'the command it composed before running it, so every answer is reproducible as',
    'flags. Without a terminal a missing --name stays an error, so CI never hangs.',
+   'For a standalone project, the wizard ends by offering npm install unless',
+   '--install already requested it.',
+   'After a successful scaffold, the wizard offers coding-agent skills separately.',
+   'Skipping or cancelling that offer leaves the scaffold intact.',
    '',
    'Project options (position-free):',
    '  <target-dir>          The project directory to scaffold into (required).',
@@ -240,12 +268,22 @@ export const INIT_HELP: readonly string[] = [
    '                        --hosts, the server with its Node entry points, and',
    '                        with glsp the client/ package a host mounts.',
    '  --force               Scaffold into a non-empty directory anyway.',
+   '  --skills <names>      After scaffolding, install named skills: hydranium-profiling,',
+   `                        langium. Requires --agents. Downloads with npx ${SKILLS_INSTALLER} add`,
+   '                        --copy, preserving unrelated skills and lock entries.',
+   '                        With --monorepo, skills are written at the workspace root.',
+   '  --agents <names>      Comma-separated agents for --skills: codex, claude-code,',
+   '                        cursor, github-copilot, opencode.',
+   '  --install             Run npm install in the scaffold, with lifecycle scripts',
+   '                        and network access. Cannot be combined with --monorepo:',
+   '                        its parent manifest needs manual edits first.',
    '  --monorepo            Scaffold the packages as members of the surrounding npm',
    '                        workspace, with no root of their own: each tsconfig',
    '                        extends the root config that actually carries',
    '                        compilerOptions, and the scripts address the server by',
    '                        --prefix. Errors when no ancestor declares `workspaces`.',
-   '                        Never writes outside the target — the root `workspaces`',
+   '                        Scaffold files stay inside the target; optional skills',
+   '                        go at the workspace root. The root `workspaces`',
    '                        entries and dependency pins are printed, not added.',
    '  --scope <@scope>      npm scope for the package names, e.g. @acme. Not inferred:',
    '                        a root manifest is usually named for the repo, not the',
@@ -291,18 +329,24 @@ export async function runInitCommand(args: string[]): Promise<void> {
       printHelp(INIT_HELP);
       return;
    }
-   const parsed = parseInitArgs(args);
+   let parsed = parseInitArgs(args);
+   validateInitInstallation(parsed);
+   let selection = parseSkillInstallation(parsed.skills, parsed.agents);
+   let prompt: Awaited<ReturnType<typeof createClackPrompt>> | undefined;
    // The wizard's entry point: no `--name` on an interactive terminal. Safe
    // because that combination has no non-wizard meaning, and gated on a TTY
    // because a non-interactive caller must keep failing fast — a prompt in CI
    // hangs the job instead of reporting the missing flag.
    if (parsed.name === undefined && process.stdin.isTTY && process.stdout.isTTY) {
-      const prompt = await createClackPrompt();
+      prompt = await createClackPrompt();
       const argv = await runInitWizard(prompt, targetDir => detectWorkspace(targetDir, createNodeWorkspaceProbe()), {
          targetDir: parsed.targetDir,
+         install: parsed.install,
+         skills: parsed.skills,
+         agents: parsed.agents,
          isOccupied: isNonEmptyDir
       });
-      return runInitCommand(argv);
+      parsed = parseInitArgs(argv);
    }
    runInit({
       targetDir: assertRequired(parsed.targetDir, '<target-dir>', 'init'),
@@ -311,8 +355,19 @@ export async function runInitCommand(args: string[]): Promise<void> {
       heads: parsed.heads,
       hosts: parsed.hosts,
       force: parsed.force,
+      install: parsed.install,
       monorepo: parsed.monorepo,
       scope: parsed.scope,
       public: parsed.public
    });
+   const target = path.resolve(parsed.targetDir!);
+   const project = parsed.monorepo ? detectWorkspace(target, createNodeWorkspaceProbe())!.rootDir : target;
+   if (selection === undefined && prompt !== undefined) {
+      selection = await offerSkills(prompt, project);
+   }
+   if (selection !== undefined) {
+      installSkills(project, path.join(target, 'server'), selection);
+   } else {
+      process.stdout.write('\nOptional agent skills: see the Work with coding-agent skills guide.\n');
+   }
 }

package/src/commands/init-skills.ts

@@ -0,0 +1,129 @@
+/********************************************************************************
+ * 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 { spawnSync } from 'node:child_process';
+import * as path from 'node:path';
+import { InitWizardCancelled, type PromptPort } from './init-prompt.js';
+import { checkSkills } from './skills.js';
+
+export const SKILLS_INSTALLER = 'skills@1.7.6';
+
+export const ADOPTER_SKILLS = {
+   'hydranium-profiling': { source: 'eclipse-emfcloud/hydranium', label: 'Hydranium profiling' },
+   langium: { source: 'eclipse-langium/langium-ai', label: 'Langium grammar and runtime' }
+} as const;
+
+export type AdopterSkill = keyof typeof ADOPTER_SKILLS;
+
+export const SKILL_AGENTS = {
+   codex: 'Codex',
+   'claude-code': 'Claude Code',
+   cursor: 'Cursor',
+   'github-copilot': 'GitHub Copilot',
+   opencode: 'OpenCode'
+} as const;
+
+export type SkillAgent = keyof typeof SKILL_AGENTS;
+
+export interface SkillInstallation {
+   readonly skills: readonly AdopterSkill[];
+   readonly agents: readonly SkillAgent[];
+}
+
+/** Validate before scaffolding so a misspelling cannot leave a half-completed command. */
+export function parseSkillInstallation(skills?: string, agents?: string): SkillInstallation | undefined {
+   if (skills === undefined && agents === undefined) {
+      return undefined;
+   }
+   if (!skills || !agents) {
+      throw new Error('--skills and --agents must be supplied together.');
+   }
+   const selectedSkills = skills.split(',');
+   const selectedAgents = agents.split(',');
+   for (const name of selectedSkills) {
+      if (!Object.hasOwn(ADOPTER_SKILLS, name)) {
+         throw new Error(`Unknown skill '${name}'. Choose ${Object.keys(ADOPTER_SKILLS).join(', ')}.`);
+      }
+   }
+   for (const name of selectedAgents) {
+      if (!Object.hasOwn(SKILL_AGENTS, name)) {
+         throw new Error(`Unknown agent '${name}'. Choose ${Object.keys(SKILL_AGENTS).join(', ')}.`);
+      }
+   }
+   return { skills: [...new Set(selectedSkills)] as AdopterSkill[], agents: [...new Set(selectedAgents)] as SkillAgent[] };
+}
+
+export function skillInstallArgs(skill: AdopterSkill, agents: readonly SkillAgent[]): string[] {
+   return ['--yes', SKILLS_INSTALLER, 'add', ADOPTER_SKILLS[skill].source, '--skill', skill, '--agent', ...agents, '--copy', '--yes'];
+}
+
+/** A failed optional download leaves the scaffold usable and gives an independently runnable retry. */
+export function installSkills(
+   project: string,
+   from: string,
+   selection: SkillInstallation,
+   write: (message: string) => void = message => process.stdout.write(message)
+): void {
+   for (const skill of selection.skills) {
+      const args = skillInstallArgs(skill, selection.agents);
+      write(`\nIn ${project}: npx ${args.join(' ')}\n`);
+      try {
+         // Only catalogued names reach the Windows shim's shell; paths travel as cwd, never shell text.
+         const result = spawnSync(process.platform === 'win32' ? 'npx.cmd' : 'npx', args, {
+            cwd: project,
+            stdio: 'inherit',
+            shell: process.platform === 'win32'
+         });
+         if (result.signal === 'SIGINT' || result.status === 130) {
+            write('Skill installation cancelled. Scaffold kept.\n');
+            return;
+         }
+         if (result.error || result.signal || result.status !== 0) {
+            throw result.error ?? new Error(result.signal ?? `exit code ${result.status}`);
+         }
+         for (const result of checkSkills(project, from, [skill])) {
+            write(`${result.status}: ${result.file}: ${result.detail}\n`);
+         }
+      } catch (error) {
+         write(`Skill installation failed (${error instanceof Error ? error.message : String(error)}). Scaffold kept.\n`);
+         write(`Retry in ${project}: npx ${args.join(' ')}\n`);
+      }
+   }
+   const relative = path.relative(project, from) || '.';
+   const quoted = `'${relative.replace(/'/g, "'\\''")}'`;
+   write(`Check again after installing or updating dependencies: npx hydranium-cli check-skills --from ${quoted}\n`);
+}
+
+/** This prompt runs only after the scaffold succeeds; cancelling it cannot undo the scaffold. */
+export async function offerSkills(prompt: PromptPort, project: string): Promise<SkillInstallation | undefined> {
+   try {
+      prompt.intro('Optional coding-agent skills');
+      if (!(await prompt.confirm({ message: `Install coding-agent skills in ${project}?`, initialValue: false }))) {
+         prompt.outro('Skills skipped.');
+         return undefined;
+      }
+      const skills = await prompt.multiselect<AdopterSkill>({
+         message: 'Skills to install',
+         choices: Object.entries(ADOPTER_SKILLS).map(([value, skill]) => ({ value: value as AdopterSkill, label: skill.label })),
+         initialValues: ['hydranium-profiling', 'langium']
+      });
+      const agents = await prompt.multiselect<SkillAgent>({
+         message: 'Coding agents',
+         choices: Object.entries(SKILL_AGENTS).map(([value, label]) => ({ value: value as SkillAgent, label }))
+      });
+      prompt.outro('Installing selected skills as project files. Commit the files and skills-lock.json.');
+      return { skills, agents };
+   } catch (error) {
+      if (error instanceof InitWizardCancelled) {
+         prompt.outro('Skills skipped. Scaffold kept.');
+         return undefined;
+      }
+      throw error;
+   }
+}

package/src/commands/init-wizard.ts

@@ -39,6 +39,9 @@
  *   posture rather than a packaging detail: the emission withholds publication
  *   AND declares itself UNLICENSED, so a default nobody was shown would settle
  *   the licence question by silence.
+ * - **installation**, which opts into network access and lifecycle scripts.
+ *   Workspace members need parent-manifest edits first, so only standalone
+ *   projects offer it, unless the caller already supplied `--install`.
  *
  * The **language id is deliberately not asked**, though it is the third of the
  * three independent names: its derivation was settled and built separately
@@ -91,6 +94,10 @@ export interface InitAnswers {
    readonly scope?: string;
    /** Leave the package publishable, which the scaffold does not do by default. */
    readonly public: boolean;
+   /** Run npm install after writing the scaffold. */
+   readonly install: boolean;
+   readonly skills?: string;
+   readonly agents?: string;
 }
 
 /** PascalCase a directory name, splitting on any non-alphanumeric run. */
@@ -153,6 +160,12 @@ export function composeInitArgv(answers: InitAnswers): string[] {
    if (answers.public) {
       argv.push('--public');
    }
+   if (answers.install) {
+      argv.push('--install');
+   }
+   if (answers.skills !== undefined && answers.agents !== undefined) {
+      argv.push('--skills', answers.skills, '--agents', answers.agents);
+   }
    return argv;
 }
 
@@ -350,7 +363,13 @@ async function askPackaging(
 export async function runInitWizard(
    prompt: PromptPort,
    detect: (targetDir: string) => WorkspaceDetection | undefined,
-   options: { readonly targetDir?: string; readonly isOccupied?: (targetDir: string) => boolean } = {}
+   options: {
+      readonly targetDir?: string;
+      readonly isOccupied?: (targetDir: string) => boolean;
+      readonly install?: boolean;
+      readonly skills?: string;
+      readonly agents?: string;
+   } = {}
 ): Promise<string[]> {
    prompt.intro('Scaffold a Hydranium language project');
 
@@ -392,9 +411,31 @@ export async function runInitWizard(
    } while (await prompt.confirm({ message: 'Add another grammar?', initialValue: false }));
 
    const withDiagram = await askDiagramGrammar(prompt, heads, grammars);
-   const packaging = await askPackaging(prompt, detect(targetDir), heads, hosts);
+   const detection = detect(targetDir);
+   if (options.install && detection !== undefined) {
+      prompt.note('--install requires a standalone project; workspace membership is skipped.', 'Installation');
+   }
+   const packaging = await askPackaging(prompt, options.install ? undefined : detection, heads, hosts);
+   const install =
+      (options.install ?? false) ||
+      (!packaging.monorepo &&
+         (await prompt.confirm({
+            message: 'Install dependencies now (npm install)?',
+            initialValue: false
+         })));
 
-   const argv = composeInitArgv({ targetDir, name, heads, hosts, grammars: withDiagram, force, ...packaging });
+   const argv = composeInitArgv({
+      targetDir,
+      name,
+      heads,
+      hosts,
+      grammars: withDiagram,
+      force,
+      install,
+      skills: options.skills,
+      agents: options.agents,
+      ...packaging
+   });
    // Echoed as the LAST thing before the scaffold runs, because it is the
    // artefact the session produces: everything above is how it was reached.
    prompt.outro(formatCommand(argv));

package/src/commands/init.ts

@@ -284,6 +284,8 @@ export interface InitCommandOptions {
    readonly hosts?: readonly InitHost[];
    /** Scaffold into a non-empty directory anyway. */
    readonly force?: boolean;
+   /** Install dependencies after scaffolding. Only supported for standalone projects. */
+   readonly install?: boolean;
    /**
     * Scaffold a member of the surrounding npm workspace: extend its base
     * tsconfig and address the package by `--prefix` in the scripts it prints
@@ -597,16 +599,21 @@ function formatScaffold(targetDir: string, files: readonly InitFile[], write: (l
    }
 }
 
+export function validateInitInstallation(options: Pick<InitCommandOptions, 'install' | 'monorepo'>): void {
+   if (options.install && options.monorepo) {
+      throw new Error('--install cannot be combined with --monorepo: update the parent workspace manifest before running npm install.');
+   }
+}
+
 /**
  * Scaffold a new Hydranium language project end-to-end: one starter grammar per
  * `--grammar`, `create<Name>Services` DI wiring, a launcher for each head in
- * `--heads`, `langium-config.json`, `package.json`, and scripts. Does NOT run `npm install`
- * or `langium generate` — those are printed as next steps, so the command stays
- * offline and changes nothing beyond the files it writes, which a standalone
- * scaffold's oxfmt then formats. Refuses a non-empty target directory unless
- * `force`.
+ * `--heads`, `langium-config.json`, `package.json`, and scripts. Stays offline
+ * unless `install` opts into npm and its lifecycle scripts. Building remains a
+ * next step. Refuses a non-empty target directory unless `force`.
  */
 export function runInit(options: InitCommandOptions): void {
+   validateInitInstallation(options);
    const write = options.write ?? ((line: string) => process.stdout.write(line));
    const targetDir = path.resolve(options.targetDir);
    const detection = options.monorepo ? detectWorkspace(targetDir, options.probe ?? createNodeWorkspaceProbe()) : undefined;
@@ -691,6 +698,41 @@ export function runInit(options: InitCommandOptions): void {
          write(`  Sibling packages all use the "${detection.scope}" scope; pass --scope ${detection.scope} to match them.\n`);
       }
    }
+   if (options.install) {
+      write('\nRunning npm install...\n');
+      const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+      // --prefix also changes npm's default globalconfig. Resolve it first without walking into an enclosing workspace.
+      const config = spawnSync(npm, ['config', 'get', 'globalconfig', '--workspaces=false'], {
+         cwd: targetDir,
+         encoding: 'utf8',
+         stdio: ['ignore', 'pipe', 'inherit'],
+         shell: process.platform === 'win32'
+      });
+      const globalconfig = config.stdout?.trim();
+      if (config.error || config.signal || config.status !== 0 || !globalconfig) {
+         const reason = config.error?.message ?? (config.signal ? `signal ${config.signal}` : `exit code ${config.status}`);
+         throw new Error(
+            `Could not read npm global configuration (${reason}). Scaffold kept at ${targetDir}; installation was not started.`
+         );
+      }
+      const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => key.toLowerCase() !== 'npm_config_globalconfig'));
+      env.npm_config_globalconfig = globalconfig;
+      // An explicit prefix keeps npm from selecting an enclosing workspace instead of this standalone root.
+      // Windows resolves npm through a command shim; only fixed arguments reach the shell.
+      const result = spawnSync(npm, ['--prefix', '.', 'install'], {
+         cwd: targetDir,
+         stdio: 'inherit',
+         shell: process.platform === 'win32',
+         env
+      });
+      if (result.error || result.signal || result.status !== 0) {
+         const reason = result.error?.message ?? (result.signal ? `signal ${result.signal}` : `exit code ${result.status}`);
+         throw new Error(
+            `npm install failed (${reason}). Scaffold kept at ${targetDir}. ` +
+               `Set npm_config_globalconfig to ${globalconfig} to preserve npm's global configuration. Run npm --prefix . install there to retry.`
+         );
+      }
+   }
    write('\n');
    write('Next steps:\n');
    // A workspace member's project has no manifest of its own, so its steps run
@@ -703,7 +745,9 @@ export function runInit(options: InitCommandOptions): void {
       if (spawnSync('git', ['check-ignore', '-q', targetDir], { cwd: targetDir }).status === 0) {
          write('  git init                 # an enclosing repository ignores this folder, so lint and format find no file until then\n');
       }
-      write('  npm install\n');
+      if (!options.install) {
+         write('  npm install\n');
+      }
       write('  npm run build            # langium generate + tsc, every package\n');
       write('  npm test                 # the server tests\n');
       write('  npm run watch            # rebuild the members on every change; watch:<host> adds a host\n');