biome-plugin-suitescript 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Eric Nemchik
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,149 @@
-# Temporary Holding Version
+# biome-plugin-suitescript
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[Biome](https://biomejs.dev) lint plugins and a tag checker for NetSuite **SuiteScript 2.1**, ported from
+[acdvs/eslint-plugin-suitescript](https://github.com/acdvs/eslint-plugin-suitescript) and
+[btonasse/eslint-plugin-suitescript](https://github.com/btonasse/eslint-plugin-suitescript).
+
+Requires Biome **>= 2.6.4** (npm-distributed plugins use `biome-manifest.json`) and Node >= 22 for the CLI.
+Rules work on both AMD `define()` and ES `import`/`export` source, in `.js` and `.ts`.
+
+## Install
+
+```sh
+npm i -D @biomejs/biome biome-plugin-suitescript
+```
+
+## Use
+
+```jsonc
+// biome.json
+{
+    "extends": ["biome-plugin-suitescript/configs/suitescript2"], // globals: define, require, log, util
+    "plugins": [
+        "biome-plugin-suitescript/presets/recommended",
+        "biome-plugin-suitescript/noLogModule" // add individual rules on top of a preset
+    ]
+}
+```
+
+Run the tag checker beside `biome check` (see [Tag checker](#tag-checker)):
+
+```sh
+npx biome-plugin-suitescript check
+```
+
+## Rules
+
+Each rule has one fixed severity: `error` for things that fail at runtime or on upload, `warn` for conventions.
+Biome plugins cannot be reconfigured per project, so you choose by enabling rules, scoping them, or generating one.
+
+| Rule                           | Severity | Description                                                                        | ESLint equivalent           |
+| ------------------------------ | -------- | ---------------------------------------------------------------------------------- | --------------------------- |
+| `noAmdName` (fixable)          | error    | No module id as the first `define` argument                                        | `no-amd-name`               |
+| `noExtraModules`               | error    | Dependency array and callback parameters must match in count                       | `no-extra-modules`          |
+| `noInvalidModules`             | error    | Unknown `N/...` modules                                                            | `no-invalid-modules`        |
+| `noModuleExtensions` (fixable) | error    | No `.js` in `define` dependency names                                              | `no-module-extensions`      |
+| `moduleVars`                   | warn     | Conventional identifier per `N/` module (`N/record` → `record`)                    | `module-vars`               |
+| `logRequireTitle`              | warn     | `log.debug/audit/error/emergency({...})` needs `title`                             | `log-args` `requireTitle`   |
+| `logRequireDetails`            | warn     | ...needs `details`                                                                 | `log-args` `requireDetails` |
+| `noLogModule`                  | warn     | Use the global `log`, not `N/log`                                                  | `no-log-module`             |
+| `entryPoints`                  | error    | Returned entry points must belong to one script type and include its required ones | `entry-points`              |
+
+`noAmdName`, `noExtraModules` and `noModuleExtensions` only apply to `define()`. The rest cover `import` too.
+
+| Preset                | Contents                                                                                                    |
+| --------------------- | ----------------------------------------------------------------------------------------------------------- |
+| `presets/recommended` | every rule above except `noLogModule` and `entryPoints` (no false positives on libraries or client scripts) |
+| `presets/minimal`     | `noExtraModules`, `noInvalidModules`                                                                        |
+| `presets/all`         | `recommended` + `noLogModule` + `entryPoints`                                                               |
+
+Suppress a diagnostic with `// biome-ignore lint/plugin: reason`.
+
+### `entryPoints` and script types
+
+Biome plugins cannot read comments, so the script type is **inferred from what the module returns**
+(`beforeLoad` → User Event, `onRequest` → Suitelet, ...). The rule reports mixed entry points
+(`pageInit` with `execute`) and missing required ones (Map/Reduce needs `getInputData` and `map` or `reduce`).
+Modules that return no distinctive entry point are libraries and are ignored. Generic names such as
+`get`, `post`, `map` and `run` alone never make a module a script.
+
+### Choosing what to enforce
+
+- **Pick rules.** `log-args`' two options are the separate `logRequireTitle` / `logRequireDetails` rules.
+- **Scope with `includes`.** For example, the global `log` is not available in client scripts:
+
+  ```jsonc
+  { "path": "biome-plugin-suitescript/noLogModule", "includes": ["src/**", "!src/**/client/**"] }
+  ```
+- **Custom module identifiers.** Generate a rule with your own mapping (and omit `moduleVars`):
+
+  ```sh
+  npx biome-plugin-suitescript generate module-vars --set N/record=nRecord --out plugins/module-vars.js
+  ```
+
+  then add `"./plugins/module-vars.js"` to `plugins`.
+
+## Tag checker
+
+`@NApiVersion` and `@NScriptType` live in comments, which no Biome plugin can read, so a small CLI checks them.
+It is **report-only**: it never edits files.
+
+```sh
+npx biome-plugin-suitescript check                      # uses biome-plugin-suitescript.json
+npx biome-plugin-suitescript check "src/**/*.ts"        # or explicit globs
+npx biome-plugin-suitescript check --format github      # text (default) | json | github
+```
+
+It reports:
+
+- `@NApiVersion` other than `2.1` (2.0, 2.x, 1.0 and invalid values), or missing when the file is a script.
+- `@NScriptType` with no or an invalid value, or missing when the returned entry points imply one.
+- A declared script type that does not match the returned entry points, or lacks its required ones.
+
+Files with no tags and no implied entry points (libraries) are skipped. For scripts still on 1.0, 2.0 or 2.x, the
+output points to Oracle's
+[`netsuite-suitescript-upgrade`](https://github.com/oracle/netsuite-suitecloud-sdk/tree/master/packages/agent-skills/netsuite-suitescript-upgrade)
+agent skill for the conversion.
+
+Exit codes: `0` clean, `1` problems found, `2` usage or configuration error.
+
+### Configuration
+
+List only the **script sources**: files deployed to the file cabinet, or the sources they are transpiled from (not
+the transpiled output, and not build files such as `swc.mts`). The CLI refuses to run without a list rather than
+guessing from `deploy.xml`.
+
+```jsonc
+// biome-plugin-suitescript.json
+{
+    "$schema": "./node_modules/biome-plugin-suitescript/schema.json",
+    "includes": ["src/TypeScripts/**/*.{js,ts}", "!**/*.d.ts", "!**/*.test.*"]
+}
+```
+
+`!` negation works as in Biome's `includes`. Reuse the same globs in the plugin `includes` in `biome.json` to scope the
+Biome rules identically.
+
+## Development
+
+The source is TypeScript under `src/`, compiled by `tsc` to `dist/` (the only code that is published). Scripts and
+tests are TypeScript too and run directly on Node. Node and npm versions come from `devEngines` in `package.json`
+(also in `.nvmrc` and `.tool-versions`).
+
+```sh
+npm install
+npm run build          # tsc -> dist/, copies GritQL rules, regenerates biome-manifest.json
+npm run typecheck      # tsc --noEmit over src, scripts and tests
+npm run check          # biome check (npm run format applies fixes)
+npm run sync-modules   # refreshes the N/ module list from @hitc/netsuite-types
+npm test               # builds first, then tests the built package
+```
+
+Git hooks (lefthook) run Biome on staged files before commit and reinstall dependencies after checkout or merge.
+
+Commits follow [Conventional Commits](https://www.conventionalcommits.org); release-please opens a release PR and
+publishes to npm when it is merged, using npm trusted publishing (OIDC, no token; the package settings on npmjs.com
+allow this repo and `release.yml`). Dependencies are managed by Renovate: dev
+dependencies are pinned, the `@biomejs/biome` peer range stays a caret, and Biome and `@biomejs/runtime` update together.
+
+MIT licensed. Module and script-type data and rule behavior derive from the MIT-licensed ESLint plugins above.

package/biome-manifest.json

@@ -0,0 +1,63 @@
+{
+  "$schema": "./node_modules/@biomejs/biome/manifest_schema.json",
+  "configs": [
+    {
+      "suitescript2": "./configs/suitescript2.json"
+    }
+  ],
+  "plugins": {
+    "presets": {
+      "all": [
+        "noAmdName",
+        "noExtraModules",
+        "noInvalidModules",
+        "noModuleExtensions",
+        "moduleVars",
+        "logRequireTitle",
+        "logRequireDetails",
+        "noLogModule",
+        "entryPoints"
+      ],
+      "minimal": ["noExtraModules", "noInvalidModules"],
+      "recommended": [
+        "noAmdName",
+        "noExtraModules",
+        "noInvalidModules",
+        "noModuleExtensions",
+        "moduleVars",
+        "logRequireTitle",
+        "logRequireDetails"
+      ]
+    },
+    "rules": [
+      {
+        "entryPoints": "./dist/rules/entryPoints.js"
+      },
+      {
+        "logRequireDetails": "./dist/rules/logRequireDetails.js"
+      },
+      {
+        "logRequireTitle": "./dist/rules/logRequireTitle.js"
+      },
+      {
+        "moduleVars": "./dist/rules/moduleVars.js"
+      },
+      {
+        "noAmdName": "./dist/rules/noAmdName.grit"
+      },
+      {
+        "noExtraModules": "./dist/rules/noExtraModules.js"
+      },
+      {
+        "noInvalidModules": "./dist/rules/noInvalidModules.js"
+      },
+      {
+        "noLogModule": "./dist/rules/noLogModule.js"
+      },
+      {
+        "noModuleExtensions": "./dist/rules/noModuleExtensions.grit"
+      }
+    ]
+  },
+  "version": 1
+}

package/configs/suitescript2.json

@@ -0,0 +1,5 @@
+{
+  "javascript": {
+    "globals": ["define", "require", "log", "util"]
+  }
+}

package/dist/bin/biome-plugin-suitescript.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { relative, resolve } from "node:path";
+import { glob } from "tinyglobby";
+import { analyzeSource } from "../cli/analyze.js";
+import { format } from "../cli/format.js";
+import { MODULES } from "../lib/modules.js";
+const USAGE = `Usage:
+  biome-plugin-suitescript check [globs...] [--config file] [--format text|json|github]
+  biome-plugin-suitescript generate module-vars [--set N/module=identifier]... [--out file.js]
+
+check reads "includes" from biome-plugin-suitescript.json unless globs are given.
+Exit codes: 0 clean, 1 problems found, 2 usage or configuration error.`;
+function fail(message) {
+    console.error(`${message}\n\n${USAGE}`);
+    process.exit(2);
+}
+function parseFlags(args, valued) {
+    const flags = {};
+    const positional = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg.startsWith("--")) {
+            positional.push(arg);
+            continue;
+        }
+        const name = arg.slice(2);
+        if (!valued.includes(name))
+            fail(`Unknown option --${name}`);
+        const value = args[i + 1];
+        if (value === undefined)
+            fail(`--${name} needs a value`);
+        flags[name] = [...(flags[name] ?? []), value];
+        i++;
+    }
+    return { flags, positional };
+}
+const isOutputFormat = (value) => value === "text" || value === "json" || value === "github";
+function readIncludes(configPath) {
+    if (!existsSync(configPath)) {
+        fail(`No globs given and no ${relative(process.cwd(), configPath)} found. List your script sources in "includes".`);
+    }
+    let config;
+    try {
+        config = JSON.parse(readFileSync(configPath, "utf8"));
+    }
+    catch (error) {
+        fail(`Could not read ${configPath}: ${error instanceof Error ? error.message : error}`);
+    }
+    const includes = config.includes;
+    if (!Array.isArray(includes) ||
+        includes.length === 0 ||
+        includes.some((g) => typeof g !== "string")) {
+        fail(`${configPath}: "includes" must be a non-empty array of glob strings`);
+    }
+    return includes;
+}
+async function check(args) {
+    const { flags, positional } = parseFlags(args, ["config", "format"]);
+    const kind = flags.format?.[0] ?? "text";
+    if (!isOutputFormat(kind))
+        fail(`Unknown format '${kind}'`);
+    const includes = positional.length > 0
+        ? positional
+        : readIncludes(resolve(flags.config?.[0] ?? "biome-plugin-suitescript.json"));
+    const files = (await glob(includes, { ignore: ["**/node_modules/**"], onlyFiles: true })).sort();
+    if (files.length === 0)
+        fail(`No files matched: ${includes.join(", ")}`);
+    const results = [];
+    let upgrade = false;
+    for (const file of files) {
+        const analysis = analyzeSource(file, readFileSync(file, "utf8"));
+        upgrade ||= analysis.upgrade;
+        results.push({ diagnostics: analysis.diagnostics, file });
+    }
+    const output = format(kind, results, { files: files.length, upgrade });
+    if (output)
+        console.log(output);
+    process.exit(results.some((r) => r.diagnostics.length) ? 1 : 0);
+}
+// Biome cannot resolve bare package imports from plugins, so the generated rule
+// inlines the compiled parsers from this package.
+function inline(file) {
+    return readFileSync(new URL(`../lib/${file}`, import.meta.url), "utf8")
+        .replace(/^import .*\n/gm, "")
+        .replace(/^export \{ stringValue \};\n?/m, "")
+        .replaceAll("export ", "");
+}
+function generate(args) {
+    const [kind, ...rest] = args;
+    if (kind !== "module-vars")
+        fail("generate supports: module-vars");
+    const { flags } = parseFlags(rest, ["set", "out"]);
+    const map = { ...MODULES };
+    for (const entry of flags.set ?? []) {
+        const [name, id] = entry.split("=");
+        if (!name || !id)
+            fail("--set expects N/module=identifier");
+        map[name] = id;
+    }
+    const out = flags.out?.[0] ?? "suitescript-module-vars.js";
+    writeFileSync(out, `// Generated by biome-plugin-suitescript. Add to biome.json "plugins".
+import { defineRule, ast, registerDiagnostic } from "@biomejs/runtime/plugin";
+
+${inline("define.js")}
+${inline("biome-modules.js")}
+const MODULES = ${JSON.stringify(map, null, 2)};
+
+export const moduleVars = defineRule({
+\tquery: ast("JS_CALL_EXPRESSION", "JS_IMPORT"),
+\trun(node) {
+\t\tfor (const { name, param } of dependencies(node)) {
+\t\t\tconst expected = name && Object.hasOwn(MODULES, name) ? MODULES[name] : undefined;
+\t\t\tif (expected && param && param.text !== expected) {
+\t\t\t\tregisterDiagnostic(param, "warning", \`Identifier for \${name} should be '\${expected}'.\`);
+\t\t\t}
+\t\t}
+\t},
+});
+`);
+    console.log(`Wrote ${out}`);
+}
+const [command, ...args] = process.argv.slice(2);
+if (command === "check")
+    await check(args);
+else if (command === "generate")
+    generate(args);
+else
+    fail(command ? `Unknown command '${command}'` : "Missing command");

package/dist/cli/analyze.js

@@ -0,0 +1,227 @@
+// Node-only analysis of a single SuiteScript source file (ESTree via oxc-parser).
+import { parseSync, } from "oxc-parser";
+import { declaredProblems, inferredProblems, inferScriptType, typeByName, } from "../lib/inference.js";
+const API_VERSION = "2.1";
+const UPGRADABLE = new Set(["1.0", "2.0", "2.x"]);
+function isCallback(node) {
+    return (node?.type === "FunctionExpression" ||
+        node?.type === "ArrowFunctionExpression");
+}
+function objectNames(object) {
+    const names = [];
+    for (const property of object.properties) {
+        if (property.type === "SpreadElement")
+            return undefined;
+        const key = property.key;
+        if (key.type === "Identifier")
+            names.push(key.name);
+        else if (key.type === "Literal")
+            names.push(String(key.value));
+    }
+    return names;
+}
+function unwrap(node) {
+    let current = node;
+    while (current?.type === "ParenthesizedExpression")
+        current = current.expression;
+    return current;
+}
+function amdReturnedNames(callback) {
+    const body = callback.body;
+    if (!body)
+        return undefined;
+    let returned;
+    let statements = [];
+    if (body.type === "BlockStatement") {
+        statements = body.body;
+        const ret = statements.find((s) => s.type === "ReturnStatement");
+        returned =
+            ret?.type === "ReturnStatement" ? unwrap(ret.argument) : undefined;
+    }
+    else {
+        returned = unwrap(body);
+    }
+    if (!returned)
+        return [];
+    if (returned.type === "ObjectExpression")
+        return objectNames(returned);
+    if (returned.type !== "Identifier")
+        return undefined;
+    const variable = returned.name;
+    const names = [];
+    for (const statement of statements) {
+        if (statement.type === "VariableDeclaration") {
+            for (const declarator of statement.declarations) {
+                const init = unwrap(declarator.init);
+                if (declarator.id.type === "Identifier" &&
+                    declarator.id.name === variable &&
+                    init?.type === "ObjectExpression") {
+                    const found = objectNames(init);
+                    if (!found)
+                        return undefined;
+                    names.push(...found);
+                }
+            }
+        }
+        else if (statement.type === "ExpressionStatement" &&
+            statement.expression.type === "AssignmentExpression") {
+            const left = statement.expression.left;
+            if (left.type === "MemberExpression" &&
+                !left.computed &&
+                left.object.type === "Identifier" &&
+                left.object.name === variable &&
+                left.property.type === "Identifier") {
+                names.push(left.property.name);
+            }
+        }
+    }
+    return names;
+}
+function exportedNames(node) {
+    const names = [];
+    const declaration = node.declaration;
+    if (declaration?.type === "FunctionDeclaration" && declaration.id) {
+        names.push(declaration.id.name);
+    }
+    if (declaration?.type === "VariableDeclaration") {
+        for (const d of declaration.declarations) {
+            if (d.id.type === "Identifier")
+                names.push(d.id.name);
+        }
+    }
+    for (const specifier of node.specifiers) {
+        const exported = specifier.exported;
+        names.push(exported.type === "Identifier" ? exported.name : String(exported.value));
+    }
+    return names;
+}
+function inspectProgram(program) {
+    let isScript = false;
+    const returned = [];
+    let opaque = false;
+    // Only trust `returned` when an inline define() callback or ES syntax was seen;
+    // factory references and UMD wrappers cannot be analysed statically.
+    let known = false;
+    for (const node of program.body) {
+        if (node.type === "ImportDeclaration" ||
+            node.type === "ExportNamedDeclaration")
+            known = true;
+        if (node.type === "ImportDeclaration" && /^N(\/|$)/.test(node.source.value))
+            isScript = true;
+        if (node.type === "ExportNamedDeclaration")
+            returned.push(...exportedNames(node));
+        if (node.type === "ExpressionStatement" &&
+            node.expression.type === "CallExpression") {
+            const call = node.expression;
+            if (call.callee.type === "Identifier" && call.callee.name === "define") {
+                isScript = true;
+                const callback = call.arguments.at(-1);
+                if (isCallback(callback)) {
+                    const names = amdReturnedNames(callback);
+                    if (names) {
+                        returned.push(...names);
+                        known = true;
+                    }
+                    else {
+                        opaque = true;
+                    }
+                }
+                else {
+                    opaque = true;
+                }
+            }
+        }
+    }
+    return { isScript, returned: opaque || !known ? undefined : returned };
+}
+function findTag(comments, name) {
+    const pattern = new RegExp(`${name}(?:[ \\t]+(\\S+))?`);
+    for (const comment of comments) {
+        if (comment.type !== "Block")
+            continue;
+        const match = pattern.exec(comment.value);
+        if (match)
+            return { offset: comment.start + 2 + match.index, value: match[1] };
+    }
+    return undefined;
+}
+function locator(source) {
+    const starts = [0];
+    for (let i = 0; i < source.length; i++) {
+        if (source[i] === "\n")
+            starts.push(i + 1);
+    }
+    return (offset) => {
+        let lo = 0;
+        let hi = starts.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if ((starts[mid] ?? 0) <= offset)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        return { column: offset - (starts[lo] ?? 0) + 1, line: lo + 1 };
+    };
+}
+/**
+ * Analyzes one file. Libraries (no tags, no implied entry points) produce no
+ * diagnostics.
+ */
+export function analyzeSource(filename, source) {
+    const diagnostics = [];
+    const at = locator(source);
+    const report = (rule, message, offset = 0) => {
+        diagnostics.push({ message, rule, ...at(offset) });
+    };
+    const parsed = parseSync(filename, source);
+    const fatal = parsed.errors.find((e) => e.severity === "Error");
+    if (fatal && parsed.program.body.length === 0) {
+        report("parse", `Could not parse file: ${fatal.message}`);
+        return { diagnostics, upgrade: false };
+    }
+    const apiVersion = findTag(parsed.comments, "@NApiVersion");
+    const scriptType = findTag(parsed.comments, "@NScriptType");
+    const { isScript, returned } = inspectProgram(parsed.program);
+    const inferred = isScript && returned ? inferScriptType(returned) : undefined;
+    // Not a script: no tags and nothing that implies an entry point.
+    if (!apiVersion && !scriptType && !inferred)
+        return { diagnostics, upgrade: false };
+    let upgrade = false;
+    if (apiVersion) {
+        if (!apiVersion.value) {
+            report("apiVersion", "No @NApiVersion value provided.", apiVersion.offset);
+        }
+        else if (apiVersion.value !== API_VERSION) {
+            upgrade = UPGRADABLE.has(apiVersion.value);
+            report("apiVersion", `@NApiVersion must be ${API_VERSION}, found '${apiVersion.value}'.`, apiVersion.offset);
+        }
+    }
+    else {
+        report("apiVersion", `Missing @NApiVersion ${API_VERSION} tag.`);
+    }
+    let declared;
+    if (scriptType) {
+        if (!scriptType.value) {
+            report("scriptType", "No @NScriptType value provided.", scriptType.offset);
+        }
+        else if (!typeByName(scriptType.value)) {
+            report("scriptType", `Invalid @NScriptType value '${scriptType.value}'.`, scriptType.offset);
+        }
+        else {
+            declared = scriptType.value;
+        }
+    }
+    else if (inferred?.types.length) {
+        const names = inferred.types.map((t) => t.name).join(" or ");
+        report("scriptType", `Missing @NScriptType tag; the returned entry points imply ${names}.`);
+    }
+    if (returned) {
+        const problems = declared
+            ? declaredProblems(declared, returned)
+            : inferredProblems(returned);
+        for (const message of problems)
+            report("entryPoints", message, scriptType?.offset ?? 0);
+    }
+    return { diagnostics, upgrade };
+}

package/dist/cli/format.js

@@ -0,0 +1,23 @@
+const escapeData = (s) => s.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
+const escapeProperty = (s) => escapeData(s).replace(/:/g, "%3A").replace(/,/g, "%2C");
+export const UPGRADE_HINT = "Upgrade old scripts with Oracle's netsuite-suitescript-upgrade agent skill (run /netsuite-suitescript-upgrade, starting with `analyze`): https://github.com/oracle/netsuite-suitecloud-sdk/tree/master/packages/agent-skills/netsuite-suitescript-upgrade";
+const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+/** Returns the text to print for the results of a run. */
+export function format(kind, results, { upgrade, files }) {
+    const all = results.flatMap((r) => r.diagnostics.map((d) => ({ file: r.file, ...d })));
+    if (kind === "json") {
+        return JSON.stringify({ diagnostics: all, files, hints: upgrade ? [UPGRADE_HINT] : [] }, null, 2);
+    }
+    if (kind === "github") {
+        return all
+            .map((d) => `::error file=${escapeProperty(d.file)},line=${d.line},col=${d.column},title=${escapeProperty(`suitescript/${d.rule}`)}::${escapeData(d.message)}`)
+            .join("\n");
+    }
+    const lines = all.map((d) => `${d.file}:${d.line}:${d.column}  ${d.rule}  ${d.message}`);
+    lines.push(all.length
+        ? `\n${plural(all.length, "problem")} in ${plural(files, "checked file")}.`
+        : `Checked ${plural(files, "file")}. No problems found.`);
+    if (upgrade)
+        lines.push(`\n${UPGRADE_HINT}`);
+    return lines.join("\n");
+}