@hydranium/cli 1.0.0-next.39 → 1.0.0-next.390

package/src/commands/init-wizard.ts

@@ -55,8 +55,10 @@
  */
 
 import * as path from 'node:path';
-import { DEFAULT_INIT_HEADS, INIT_HEADS, type InitHead, isNonEmptyDir, kebab } from './init.js';
-import { InitWizardCancelled, OPTIONAL_HEAD_CHOICES, type PromptPort } from './init-prompt.js';
+import { DEFAULT_INIT_HEADS, INIT_HEADS, type InitHead, initMembers, isNonEmptyDir, isUsableExtension, memberPlacements } from './init.js';
+import { editingHeads, INIT_HOSTS, type InitHost } from './init-hosts.js';
+import { kebab } from './kebab.js';
+import { HEAD_CHOICES, InitWizardCancelled, type PromptPort } from './init-prompt.js';
 import { type WorkspaceDetection } from './init-workspace.js';
 
 /** One grammar as the wizard collected it. */
@@ -77,6 +79,8 @@ export interface InitAnswers {
    readonly name: string;
    /** The protocol heads to start. */
    readonly heads: readonly InitHead[];
+   /** The host applications to emit around the server. */
+   readonly hosts: readonly InitHost[];
    /** The grammars, in the order they were given. */
    readonly grammars: readonly InitGrammarAnswer[];
    /** Scaffold into a non-empty directory anyway. */
@@ -117,6 +121,9 @@ export function composeInitArgv(answers: InitAnswers): string[] {
    if (answers.heads.join(',') !== DEFAULT_INIT_HEADS.join(',')) {
       argv.push('--heads', answers.heads.join(','));
    }
+   if (answers.hosts.length > 0) {
+      argv.push('--hosts', answers.hosts.join(','));
+   }
    const several = answers.grammars.length > 1;
    for (const grammar of answers.grammars) {
       // A lone grammar named after the project, taking the derived extension, is
@@ -158,13 +165,13 @@ export function formatCommand(argv: readonly string[]): string {
 /** Validate a file extension, and reject one another grammar already claims. */
 function extensionProblem(value: string, taken: ReadonlySet<string>): string | undefined {
    const extension = value.replace(/^\./, '');
-   if (!/^[A-Za-z0-9][A-Za-z0-9-]*$/.test(extension)) {
+   if (!isUsableExtension(extension)) {
       return `'${value}' is not a usable file extension.`;
    }
    // Checked here rather than left to the scaffolder so the answer is corrected
    // while the grammar that owns it is still on screen. Langium routes documents
    // to a language BY extension, so a duplicate is a silent mis-route.
-   return taken.has(extension) ? `'.${extension}' is already claimed by another grammar.` : undefined;
+   return taken.has(extension.toLowerCase()) ? `'.${extension}' is already claimed by another grammar.` : undefined;
 }
 
 /**
@@ -198,31 +205,42 @@ async function askGrammar(
    return { name, extension: extension.replace(/^\./, ''), diagram: false };
 }
 
+/** Ask for the protocol head set, in composition order whatever order they were picked in. */
+async function askHeads(prompt: PromptPort): Promise<InitHead[]> {
+   const chosen = await prompt.multiselect({ message: 'Protocol heads', choices: HEAD_CHOICES, initialValues: DEFAULT_INIT_HEADS });
+   return INIT_HEADS.filter(head => chosen.includes(head));
+}
+
+/** What the wizard asks about each host. */
+const HOST_QUESTIONS: Record<InitHost, string> = {
+   browser: 'Add a browser host (every head in a web worker, no backend)?',
+   vscode: 'Add a VS Code extension (the language client, Show Model with the data head, and a custom editor per diagram)?',
+   'theia-browser':
+      'Add a Theia browser application (the language client, Show Model with the data head, and a diagram editor per diagram)?',
+   'theia-electron': 'Add a Theia Electron application (the same as the Theia browser application, in a desktop window)?'
+};
+
 /**
- * Ask for the protocol head set.
- *
- * `lsp` is not offered, it is stated: it owns the workspace, the build pipeline
- * and the shared tier the other heads read through, so a project without it has
- * nothing for them to serve. Presenting it as a checkbox would offer a choice
- * the scaffolder then refuses.
+ * Ask for each host the head set can run, one yes/no each. A host none of
+ * whose editing heads is on is not offered: `init` would refuse it.
  */
-async function askHeads(prompt: PromptPort): Promise<InitHead[]> {
-   const optional = await prompt.multiselect({
-      message: 'Protocol heads — lsp is always included',
-      choices: OPTIONAL_HEAD_CHOICES,
-      initialValues: DEFAULT_INIT_HEADS.filter((head): head is Exclude<InitHead, 'lsp'> => head !== 'lsp')
-   });
-   const chosen = new Set<InitHead>(['lsp', ...optional]);
-   return INIT_HEADS.filter(head => chosen.has(head));
+async function askHosts(prompt: PromptPort, heads: readonly InitHead[]): Promise<InitHost[]> {
+   const hosts: InitHost[] = [];
+   for (const host of INIT_HOSTS.filter(candidate => editingHeads(candidate).some(head => heads.includes(head)))) {
+      if (await prompt.confirm({ message: HOST_QUESTIONS[host], initialValue: false })) {
+         hosts.push(host);
+      }
+   }
+   return hosts;
 }
 
 /**
  * Mark the grammar a scaffolded diagram edits.
  *
- * Only a real question with `glsp` on AND several grammars: a diagram type
- * binds exactly ONE grammar, and with a single grammar the scaffolder derives
- * that answer already — so asking would offer a choice whose "no" it would
- * silently overrule.
+ * Only a real question with `glsp` on AND several grammars: the scaffolded
+ * diagram is typed over one grammar's model, and with a single grammar the
+ * scaffolder derives that answer already — so asking would offer a choice
+ * whose "no" it would silently overrule.
  */
 async function askDiagramGrammar(
    prompt: PromptPort,
@@ -263,15 +281,18 @@ async function confirmOccupiedTarget(prompt: PromptPort, targetDir: string, isOc
 /** Ask the workspace questions, or answer them "no" when there is no workspace to join. */
 async function askWorkspaceMembership(
    prompt: PromptPort,
-   detection: WorkspaceDetection | undefined
+   detection: WorkspaceDetection | undefined,
+   heads: readonly InitHead[],
+   hosts: readonly InitHost[]
 ): Promise<{ monorepo: boolean; scope?: string }> {
    if (detection === undefined) {
       return { monorepo: false };
    }
+   const uncovered = memberPlacements(detection, initMembers(heads, hosts)).filter(placement => placement.coveredBy === undefined);
    const covered =
-      detection.coveredBy === undefined
-         ? `The root manifest has no entry covering it, so one is printed for you to add.`
-         : `Already covered by the "${detection.coveredBy}" workspaces entry.`;
+      uncovered.length === 0
+         ? 'Its packages are already covered by the workspaces entries.'
+         : `The root manifest has no entry covering ${uncovered.map(placement => placement.path).join(', ')}, so ${uncovered.length === 1 ? 'one is' : 'they are'} printed for you to add.`;
    // The placement is named, not just the root. The root alone reads as "this
    // ran somewhere I did not ask for" whenever the command was issued from a
    // different directory than the target, which is the normal case.
@@ -310,9 +331,11 @@ async function askWorkspaceMembership(
  */
 async function askPackaging(
    prompt: PromptPort,
-   detection: WorkspaceDetection | undefined
+   detection: WorkspaceDetection | undefined,
+   heads: readonly InitHead[],
+   hosts: readonly InitHost[]
 ): Promise<{ monorepo: boolean; scope?: string; public: boolean }> {
-   const membership = await askWorkspaceMembership(prompt, detection);
+   const membership = await askWorkspaceMembership(prompt, detection, heads, hosts);
    const isPublic = await prompt.confirm({ message: 'Publishable to npm (the manifest says UNLICENSED)?', initialValue: false });
    return { ...membership, public: isPublic };
 }
@@ -353,6 +376,7 @@ export async function runInitWizard(
    });
 
    const heads = await askHeads(prompt);
+   const hosts = await askHosts(prompt, heads);
 
    // One grammar at a time, each with its own settings, then an explicit "add
    // another" — so the single-grammar case costs two keystrokes and the
@@ -364,13 +388,13 @@ export async function runInitWizard(
       const grammar = await askGrammar(prompt, grammars.length, grammars.length === 0 ? name : undefined, takenNames, takenExtensions);
       grammars.push(grammar);
       takenNames.add(grammar.name);
-      takenExtensions.add(grammar.extension);
+      takenExtensions.add(grammar.extension.toLowerCase());
    } while (await prompt.confirm({ message: 'Add another grammar?', initialValue: false }));
 
    const withDiagram = await askDiagramGrammar(prompt, heads, grammars);
-   const packaging = await askPackaging(prompt, detect(targetDir));
+   const packaging = await askPackaging(prompt, detect(targetDir), heads, hosts);
 
-   const argv = composeInitArgv({ targetDir, name, heads, grammars: withDiagram, force, ...packaging });
+   const argv = composeInitArgv({ targetDir, name, heads, hosts, grammars: withDiagram, force, ...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-workspace.ts

@@ -169,14 +169,6 @@ export interface WorkspaceDetection {
    readonly workspaces: readonly string[];
    /** POSIX path of the target relative to {@link rootDir}, e.g. `packages/foo`. */
    readonly targetPath: string;
-   /**
-    * The `workspaces` glob already covering {@link targetPath}, if any.
-    *
-    * Absent means the root manifest needs a new entry — which is why this is
-    * computed per target rather than assumed: a `packages/*` glob covers a new
-    * package for free, while a repo that lists its examples one by one does not.
-    */
-   readonly coveredBy?: string;
    /** The npm scope the sibling packages agree on (`@acme`), when they agree. */
    readonly scope?: string;
    /**
@@ -186,10 +178,14 @@ export interface WorkspaceDetection {
    readonly baseTsconfig?: string;
    /** That tsconfig's `compilerOptions`, so the emitted one can drop what it inherits. */
    readonly baseCompilerOptions?: Readonly<Record<string, JsonValue>>;
-   /** The root prettier config's `printWidth`, so emitted sources wrap where the repo wraps. */
+   /** The root formatter config's `printWidth`, so emitted sources wrap where the repo wraps. */
    readonly printWidth?: number;
    /** Filename of the root eslint config, when there is one. Absent means the repo does not lint. */
    readonly eslintConfig?: string;
+   /** Filename of the root Oxlint config, when present. */
+   readonly oxlintConfig?: string;
+   /** The npm version the root's `packageManager` field declares, when it names npm. */
+   readonly packageManagerNpm?: string;
 }
 
 /**
@@ -339,7 +335,7 @@ export function findBaseTsconfig(
 }
 
 /**
- * The repo's prettier `printWidth`, so the emitted sources wrap where the repo
+ * The repo's formatter `printWidth`, so the emitted sources wrap where the repo
  * wraps instead of at the scaffold's own default.
  *
  * **Why this is worth detecting at all.** There is no width that is stable for
@@ -360,19 +356,21 @@ export function findBaseTsconfig(
  * adopter's formatter rewraps on first commit. So a heuristic that is usually
  * right strictly improves on no detection, and can break nothing.
  */
-export function findPrettierPrintWidth(rootDir: string, probe: WorkspaceProbe): number | undefined {
+export function findFormatterPrintWidth(rootDir: string, probe: WorkspaceProbe): number | undefined {
    const manifest = probe.readJson(path.join(rootDir, 'package.json'));
    if (isJsonObject(manifest) && isJsonObject(manifest.prettier) && typeof manifest.prettier.printWidth === 'number') {
       return manifest.prettier.printWidth;
    }
    const present = probe.listFiles(rootDir);
-   for (const file of present.filter(name => name === '.prettierrc' || name === '.prettierrc.json')) {
+   for (const file of present.filter(name => name === '.oxfmtrc.json' || name === '.prettierrc' || name === '.prettierrc.json')) {
       const parsed = probe.readJson(path.join(rootDir, file));
       if (isJsonObject(parsed) && typeof parsed.printWidth === 'number') {
          return parsed.printWidth;
       }
    }
-   for (const file of present.filter(name => /^(\.prettierrc\.[cm]?[jt]s|prettier\.config\.[cm]?[jt]s)$/.test(name))) {
+   for (const file of present.filter(name =>
+      /^(\.prettierrc\.[cm]?[jt]s|prettier\.config\.[cm]?[jt]s|oxfmt\.config\.[cm]?[jt]s)$/.test(name)
+   )) {
       const width = /\bprintWidth\s*:\s*(\d+)/.exec(probe.readText(path.join(rootDir, file)) ?? '');
       if (width) {
          return Number(width[1]);
@@ -398,6 +396,22 @@ export function findEslintConfig(rootDir: string, probe: WorkspaceProbe): string
    return probe.listFiles(rootDir).find(name => /^eslint\.config\.[cm]?[jt]s$/.test(name) || /^\.eslintrc(\..+)?$/.test(name));
 }
 
+/** Detect Oxlint without evaluating executable configuration files. */
+export function findOxlintConfig(rootDir: string, probe: WorkspaceProbe): string | undefined {
+   return probe.listFiles(rootDir).find(name => /^(oxlint\.config\.[cm]?[jt]s|\.oxlintrc\.jsonc?)$/.test(name));
+}
+
+/** The npm version the root's `packageManager` field declares (`npm@11.15.0` gives `11.15.0`), when it names npm. */
+export function findPackageManagerNpm(rootDir: string, probe: WorkspaceProbe): string | undefined {
+   const manifest = probe.readJson(path.join(rootDir, 'package.json'));
+   return parseNpmVersion(isJsonObject(manifest) && typeof manifest.packageManager === 'string' ? manifest.packageManager : undefined);
+}
+
+/** The npm version, prerelease included, of a `packageManager` field (`npm@…`) or a user agent (`npm/…`); undefined for another tool. */
+export function parseNpmVersion(spec: string | undefined): string | undefined {
+   return /^npm[@/](\d+\.\d+\.\d+(?:-[\w.]+)?)/.exec(spec ?? '')?.[1];
+}
+
 /** POSIX-style relative path, which is what both `extends` and `--prefix` want on every platform. */
 function posixRelative(from: string, to: string): string {
    return path.relative(from, to).split(path.sep).join('/');
@@ -432,11 +446,12 @@ export function detectWorkspace(targetDir: string, probe: WorkspaceProbe): Works
       rootDir,
       workspaces,
       targetPath,
-      coveredBy: workspaces.find(glob => workspaceGlobCovers(glob, targetPath)),
       scope: inferPackageScope(rootDir, workspaces, probe),
       baseTsconfig: base && posixRelative(absoluteTarget, path.join(rootDir, base.file)),
       baseCompilerOptions: base?.compilerOptions,
-      printWidth: findPrettierPrintWidth(rootDir, probe),
-      eslintConfig: findEslintConfig(rootDir, probe)
+      printWidth: findFormatterPrintWidth(rootDir, probe),
+      eslintConfig: findEslintConfig(rootDir, probe),
+      oxlintConfig: findOxlintConfig(rootDir, probe),
+      packageManagerNpm: findPackageManagerNpm(rootDir, probe)
    };
 }