@scalar/cli 2.0.0 → 2.1.0

package/chunks/action-CYP4VDK3.js

@@ -0,0 +1,148 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  readAndParseConfig,
+  renderConfigError
+} from "./chunk-P2VH7DOC.js";
+import {
+  CONFIG_FILE_DEFAULT,
+  findConfig,
+  legacyTo2_0_0
+} from "./chunk-47Y4L5IT.js";
+import "./chunk-5BPPGTUU.js";
+import "./chunk-4QS7SJTG.js";
+import "./chunk-VTYTPSXO.js";
+import "./chunk-TLFMATXR.js";
+import {
+  ConfigVersion
+} from "./chunk-ISGLWBXZ.js";
+import "./chunk-H2WRMLYY.js";
+import "./chunk-K74E42RV.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/project/upgrade/action.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+import { text } from "@clack/prompts";
+import as from "ansis";
+import { n } from "neverpanic";
+
+// src/errors.ts
+function createError(code, detail) {
+  return {
+    code,
+    detail
+  };
+}
+function displayError(error, fallback = "Unknown error occurred. Please contact support@scalar.com") {
+  try {
+    if (error instanceof Error) {
+      return error.message;
+    }
+    if (typeof error === "object") {
+      return JSON.stringify(error);
+    }
+    if (typeof error === "string") {
+      return error;
+    }
+    return fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+// src/domains/project/upgrade/action.ts
+async function upgradeAction(__configPath) {
+  const configPath = __configPath || findConfig() || await text({
+    message: "Where is your configuration file located?",
+    defaultValue: CONFIG_FILE_DEFAULT,
+    placeholder: CONFIG_FILE_DEFAULT
+  });
+  const parseConfigResult = readAndParseConfig(configPath);
+  if (!parseConfigResult.success) {
+    renderConfigError(parseConfigResult.error);
+  }
+  if (parseConfigResult.success) {
+    output.info().line(
+      `${as.green("[SUCCESS]")} ${as.green("Configuration is valid:")} ${as.green(parseConfigResult.filePath)}`
+    ).print();
+  }
+  const { config } = parseConfigResult;
+  if (config.version === ConfigVersion.V2) {
+    return output.info().title("Your Scalar configuration is already upgraded").message(
+      "You are already on the latest Scalar docs version. No further action required."
+    ).exit("success");
+  }
+  const upgradedConfigResult = n.fromUnsafe(
+    () => legacyTo2_0_0(config),
+    (originalError) => createError("FAILED_TO_UPGRADE_CONFIG_V1", originalError)
+  );
+  if (!upgradedConfigResult.success) {
+    return output.error().title("Could not upgrade config.").message(upgradedConfigResult.error.code).message(displayError(upgradedConfigResult.error.detail)).exit("error");
+  }
+  const { upgradedConfig, legacyTheme, legacyFooter, legacyScript } = upgradedConfigResult.data;
+  if (legacyTheme) {
+    const writeUpgradedThemeResult = await n.fromUnsafe(
+      () => fs.writeFile(
+        path.resolve(
+          path.dirname(parseConfigResult.filePath),
+          config.root ?? "./",
+          legacyTheme.path
+        ),
+        legacyTheme.cssString
+      ),
+      (originalError) => createError("FAILED_TO_WRITE_UPGRADED_THEME", originalError)
+    );
+    if (!writeUpgradedThemeResult.success) {
+      return output.error().title("Could not save upgraded theme.").message(writeUpgradedThemeResult.error.code).message(displayError(writeUpgradedThemeResult.error.detail)).exit("error");
+    }
+  }
+  if (legacyFooter) {
+    const writeUpgradedFooterResult = await n.fromUnsafe(
+      () => fs.writeFile(
+        path.resolve(
+          path.dirname(parseConfigResult.filePath),
+          config.root ?? "./",
+          legacyFooter.path
+        ),
+        legacyFooter.footerString
+      ),
+      (originalError) => createError("FAILED_TO_WRITE_UPGRADED_FOOTER", originalError)
+    );
+    if (!writeUpgradedFooterResult.success) {
+      return output.error().title("Could not save upgraded footer.").message(writeUpgradedFooterResult.error.code).message(displayError(writeUpgradedFooterResult.error.detail)).exit("error");
+    }
+  }
+  if (legacyScript) {
+    const writeUpgradedScriptResult = await n.fromUnsafe(
+      () => fs.writeFile(
+        path.resolve(
+          path.dirname(parseConfigResult.filePath),
+          config.root ?? "./",
+          legacyScript.path
+        ),
+        legacyScript.scriptString
+      ),
+      (originalError) => createError("FAILED_TO_WRITE_UPGRADED_SCRIPT", originalError)
+    );
+    if (!writeUpgradedScriptResult.success) {
+      return output.error().title("Could not save upgraded head script.").message(writeUpgradedScriptResult.error.code).message(displayError(writeUpgradedScriptResult.error.detail)).exit("error");
+    }
+  }
+  const writeUpgradedConfigResult = await n.fromUnsafe(
+    () => fs.writeFile(
+      parseConfigResult.filePath,
+      JSON.stringify(upgradedConfig, null, 2)
+    ),
+    (originalError) => createError("FAILED_TO_WRITE_UPGRADED_CONFIG", originalError)
+  );
+  if (!writeUpgradedConfigResult.success) {
+    return output.error().title("Could not save upgraded config.").message(writeUpgradedConfigResult.error.code).message(displayError(writeUpgradedConfigResult.error.detail)).exit("error");
+  }
+  return output.info().title("Successfully upgraded Scalar Docs configuration!").message("Run `scalar project preview` to preview your project").exit("success");
+}
+export {
+  upgradeAction
+};

package/chunks/action-DFKHSDFV.js

@@ -0,0 +1,36 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getFileOrUrl
+} from "./chunk-23I5PKZZ.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/document/markdown/action.ts
+import fs from "node:fs";
+import as from "ansis";
+import { createMarkdownFromOpenApi } from "@scalar/openapi-to-markdown";
+async function markdownAction(inputArgument, { output: outputPath }) {
+  const startTime = performance.now();
+  if (!inputArgument) {
+    return output.error().title("Invalid argument").message("Please provide a file path or URL").exit("error");
+  }
+  const specification = await getFileOrUrl(inputArgument);
+  const markdown = await createMarkdownFromOpenApi(specification);
+  if (outputPath) {
+    fs.writeFileSync(outputPath, markdown, "utf8");
+    const endTime = performance.now();
+    output.info().line(
+      `${as.green("Markdown generated")} ${as.grey(
+        `in ${as.white(`${as.bold(`${Math.round(endTime - startTime)}`)} ms`)}`
+      )}`
+    ).line(`Written to ${as.cyan(outputPath)}`).print();
+    return;
+  }
+  process.stdout.write(markdown);
+}
+export {
+  markdownAction
+};

package/chunks/action-F4Y6Q2VB.js

@@ -0,0 +1,92 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  apiService
+} from "./chunk-SXYALPYK.js";
+import {
+  BaseCollections
+} from "./chunk-2BSG2QHO.js";
+import {
+  getDatabaseClient
+} from "./chunk-SHSHFGA7.js";
+import "./chunk-UPUTMFD4.js";
+import "./chunk-B6QZJWCQ.js";
+import "./chunk-5BPPGTUU.js";
+import "./chunk-P646T2WH.js";
+import "./chunk-4QS7SJTG.js";
+import "./chunk-VTYTPSXO.js";
+import {
+  getAuthData
+} from "./chunk-5BISXQX4.js";
+import "./chunk-OAXFCOJV.js";
+import "./chunk-TLFMATXR.js";
+import {
+  teamSchema
+} from "./chunk-4DGQIAJX.js";
+import {
+  namespaceSchema
+} from "./chunk-ISGLWBXZ.js";
+import {
+  external_exports
+} from "./chunk-H2WRMLYY.js";
+import "./chunk-K74E42RV.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output,
+  printTable
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/registry/list/action.ts
+import as from "ansis";
+async function listAction(args) {
+  const { error, data } = external_exports.object({
+    namespace: namespaceSchema.optional()
+  }).safeParse({
+    namespace: args.namespace
+  });
+  if (error)
+    return output.error().title("Invalid input").message(error.issues[0].message).exit("error");
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  const client = await getDatabaseClient();
+  const team = await client.getOne({
+    collectionPath: BaseCollections.Teams,
+    query: {
+      uid: auth.teamUid
+    },
+    schema: teamSchema
+  });
+  if (team.error)
+    return output.error().title("An error occurred when fetching your team.").message(team.message).exit("error");
+  const namespace = data.namespace || team.data.namespaces.at(0);
+  if (!namespace) {
+    return output.error().title("Missing namespace").message(
+      "Could not find a valid namespace for your API. Please specify a namespace or contact support."
+    ).exit("error");
+  }
+  const apiClient = await apiService();
+  const listApisRes = await apiClient.managedDocs.getApiDocs(namespace);
+  if (listApisRes.error)
+    return output.error().title(listApisRes.message).exit("error");
+  if (listApisRes.data.length === 0) {
+    output.info().title(`No registry APIs found for namespace "${namespace}".`).print();
+    return;
+  }
+  printTable(
+    [
+      { name: "title", title: "Title", alignment: "left", maxLen: 40 },
+      { name: "name", title: "Name", alignment: "left", color: "blue" },
+      { name: "version", title: "Version", alignment: "left" },
+      { name: "access", title: "Access", alignment: "left" }
+    ],
+    listApisRes.data.map((api) => ({
+      title: api.title || as.dim("\u2014"),
+      name: `@${api.namespace}/${api.slug}`,
+      version: api.version,
+      access: api.isPrivate ? as.green("Private") : as.yellow("Public")
+    }))
+  );
+}
+export {
+  listAction
+};

package/chunks/action-GB6DM53B.js

@@ -0,0 +1,70 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  measureTime
+} from "./chunk-KHDYYVYF.js";
+import {
+  getFileOrUrl
+} from "./chunk-23I5PKZZ.js";
+import {
+  require_dist
+} from "./chunk-K74E42RV.js";
+import {
+  isUrl,
+  isYamlFileName
+} from "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import {
+  __toESM
+} from "./chunk-3MZYUBJ6.js";
+
+// src/domains/document/upgrade/action.ts
+var import_yaml = __toESM(require_dist(), 1);
+import fs from "node:fs/promises";
+import { confirm } from "@clack/prompts";
+import as from "ansis";
+import { normalize } from "@scalar/json-magic/helpers/normalize";
+import { upgrade } from "@scalar/openapi-upgrader";
+var isDocument = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+async function upgradeAction(input, { output: outputFilePath }) {
+  if (!input) {
+    return output.error().title("Missing input").message("Please provide a file path or URL to upgrade").exit("error");
+  }
+  const isUrlInput = isUrl(input);
+  if (!outputFilePath) {
+    if (isUrlInput) {
+      return output.error().message(
+        "Please provide an output file using the -o flag when upgrading from a URL."
+      ).exit("error");
+    }
+    const shouldContinue = await confirm({
+      message: "No output file specified - this will overwrite the input file. Continue?",
+      initialValue: false
+    });
+    if (shouldContinue !== true) {
+      return output.error().message("Operation cancelled by user").exit("error");
+    }
+  }
+  const outputFileName = outputFilePath ?? input;
+  const document = normalize(await getFileOrUrl(input));
+  if (!isDocument(document)) {
+    return output.error().title("Invalid input").message(
+      "Could not read an OpenAPI document from the input. Please provide a valid JSON or YAML file."
+    ).exit("error");
+  }
+  const { result: upgraded, executionTimeMs } = await measureTime(
+    () => upgrade(document, "3.1")
+  );
+  const isYaml = isYamlFileName(outputFileName);
+  await fs.writeFile(
+    outputFileName,
+    isYaml ? import_yaml.default.stringify(upgraded) : JSON.stringify(upgraded, null, 2)
+  );
+  output.info().message(
+    `${as.green(`\u2728 OpenAPI Schema upgraded to version ${upgraded.openapi}`)} in ${as.white(`${as.bold(`${executionTimeMs.toFixed(2)}`)} ms`)}`
+  ).print();
+}
+export {
+  upgradeAction
+};

package/chunks/action-GEBRPNRT.js

@@ -0,0 +1,87 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  fetchFromRegistry
+} from "./chunk-NUXPNUSS.js";
+import "./chunk-T7MDADON.js";
+import {
+  registry
+} from "./chunk-DOVIWNKQ.js";
+import "./chunk-4QS7SJTG.js";
+import "./chunk-VTYTPSXO.js";
+import {
+  getAuthData
+} from "./chunk-5BISXQX4.js";
+import "./chunk-OAXFCOJV.js";
+import "./chunk-TLFMATXR.js";
+import "./chunk-4DGQIAJX.js";
+import {
+  docVersionSchema
+} from "./chunk-ISGLWBXZ.js";
+import {
+  external_exports
+} from "./chunk-H2WRMLYY.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/registry/get/action.ts
+import fs from "node:fs/promises";
+var versionSchema = external_exports.union([docVersionSchema, external_exports.literal("latest")]);
+async function getAction(namespace, slug, args) {
+  if (!namespace) {
+    output.error().title("Invalid input").message("Please provide namespace of the document").exit("error");
+    return;
+  }
+  if (!slug) {
+    output.error().title("Invalid input").message("Please provide slug of the document").exit("error");
+    return;
+  }
+  const result = external_exports.object({
+    version: versionSchema,
+    format: external_exports.enum(["json", "yaml"]),
+    output: external_exports.string().min(1).optional()
+  }).safeParse({
+    version: args.version ?? "latest",
+    format: args.format,
+    output: args.output
+  });
+  if (result.error) {
+    output.error().title("Invalid input").message(result.error.issues[0].message).exit("error");
+    return;
+  }
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  const fetchResult = await fetchFromRegistry(
+    registry(namespace).apis(slug).url({
+      version: result.data.version,
+      format: result.data.format
+    }),
+    auth.accessToken
+  );
+  if (fetchResult.error) {
+    output.error().title("Unable to download document").message(fetchResult.message).exit("error");
+    return;
+  }
+  const document = fetchResult.data;
+  const withTrailingNewline = document.endsWith("\n") ? document : `${document}
+`;
+  if (result.data.output) {
+    try {
+      await fs.writeFile(result.data.output, withTrailingNewline, "utf8");
+    } catch (error) {
+      const message = error instanceof Error && error.message.length > 0 ? error.message : `Could not write to ${result.data.output}.`;
+      output.error().title("Unable to write document to file").message(message).exit("error");
+      return;
+    }
+    output.info().line(
+      `Downloaded ${namespace}/${slug}@${result.data.version} (${result.data.format})`
+    ).line(`Written to ${result.data.output}`).print();
+    return;
+  }
+  process.stdout.write(withTrailingNewline);
+}
+export {
+  getAction
+};

package/chunks/action-H5OHT2GV.js

@@ -0,0 +1,56 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getFileOrUrl
+} from "./chunk-23I5PKZZ.js";
+import {
+  require_dist
+} from "./chunk-K74E42RV.js";
+import {
+  isYamlFileName
+} from "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import {
+  __toESM
+} from "./chunk-3MZYUBJ6.js";
+
+// src/domains/document/postman/action.ts
+var import_yaml = __toESM(require_dist(), 1);
+import fs from "node:fs";
+import as from "ansis";
+import { convert } from "@scalar/postman-to-openapi";
+async function convertAction(inputArgument, {
+  output: outputPath,
+  mergeOperations
+}) {
+  const startTime = performance.now();
+  if (!inputArgument) {
+    return output.error().title("Invalid argument").message("Please provide a Postman collection file path or URL").exit("error");
+  }
+  const collection = await getFileOrUrl(inputArgument);
+  let specification;
+  try {
+    specification = convert(collection, {
+      mergeOperation: !!mergeOperations
+    });
+  } catch {
+    return output.error().title("Failed to convert Postman collection").message("The provided input is not a valid Postman collection").exit("error");
+  }
+  const openApiDocument = outputPath ? isYamlFileName(outputPath) ? import_yaml.default.stringify(specification) : JSON.stringify(specification, null, 2) : JSON.stringify(specification, null, 2);
+  if (outputPath) {
+    fs.writeFileSync(outputPath, openApiDocument, "utf8");
+    const endTime = performance.now();
+    output.info().line(
+      `${as.green("OpenAPI document generated")} ${as.grey(
+        `in ${as.white(`${as.bold(`${Math.round(endTime - startTime)}`)} ms`)}`
+      )}`
+    ).line(`Written to ${as.cyan(outputPath)}`).print();
+    return;
+  }
+  process.stdout.write(`${openApiDocument}
+`);
+}
+export {
+  convertAction
+};

package/chunks/action-HD2T6BFJ.js

@@ -0,0 +1,54 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getUserTeams
+} from "./chunk-ASMHW5AY.js";
+import {
+  getDatabaseClient
+} from "./chunk-SHSHFGA7.js";
+import "./chunk-B6QZJWCQ.js";
+import {
+  getAuthData
+} from "./chunk-5BISXQX4.js";
+import "./chunk-OAXFCOJV.js";
+import "./chunk-4DGQIAJX.js";
+import "./chunk-ISGLWBXZ.js";
+import "./chunk-H2WRMLYY.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output,
+  printTable
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/team/list/action.ts
+import as from "ansis";
+async function listAction() {
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  const client = await getDatabaseClient();
+  const teams = await getUserTeams(client, auth.email ?? "default email");
+  if (teams.error) {
+    return output.error().title("An error occurred while getting list of teams.").exit("error");
+  }
+  if (teams.data.length === 0) {
+    output.info().title("You are not part of any teams.").print();
+    return;
+  }
+  printTable(
+    [
+      { name: "current", title: " ", alignment: "center" },
+      { name: "team", title: "Team", alignment: "left" }
+    ],
+    teams.data.map((it) => {
+      const isCurrentTeam = it.teamUid === auth.teamUid;
+      const color = isCurrentTeam ? as.green : as.blue;
+      return {
+        current: isCurrentTeam ? color("\u279C") : " ",
+        team: isCurrentTeam ? color(`${it.teamName} (default)`) : color(it.teamName)
+      };
+    })
+  );
+}
+export {
+  listAction
+};

package/chunks/action-HNKM3Q65.js

@@ -0,0 +1,65 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  apiService
+} from "./chunk-SXYALPYK.js";
+import "./chunk-UPUTMFD4.js";
+import "./chunk-B6QZJWCQ.js";
+import "./chunk-P646T2WH.js";
+import "./chunk-4QS7SJTG.js";
+import "./chunk-VTYTPSXO.js";
+import "./chunk-5BISXQX4.js";
+import "./chunk-OAXFCOJV.js";
+import "./chunk-TLFMATXR.js";
+import "./chunk-4DGQIAJX.js";
+import "./chunk-ISGLWBXZ.js";
+import "./chunk-H2WRMLYY.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/project/create/action.ts
+import { text } from "@clack/prompts";
+import as from "ansis";
+async function createAction({
+  name,
+  slug
+}) {
+  const apiClient = await apiService();
+  let nameValue = name;
+  let slugValue = slug;
+  if (!nameValue) {
+    nameValue = await text({
+      message: "What is the name of your project?",
+      validate(value) {
+        if (value.trim().length === 0) {
+          return "You did not provide a project name. Please provide a name!";
+        }
+        return;
+      }
+    });
+  }
+  if (!slugValue) {
+    slugValue = await text({
+      message: "What is the slug of your project? (Optional)",
+      defaultValue: void 0
+    });
+  }
+  const logger = output.info().loader("Creating the project");
+  const response = await apiClient.github.createProject({
+    name: nameValue,
+    slug: slugValue
+  });
+  if (response.error) {
+    return output.error().title("Something went wrong").message(response.message).exit("error");
+  }
+  logger.update("loader", 0, { content: "Project created successfully!" });
+  logger.message(
+    `Project uid: ${as.cyan(response.data.uid)}
+Project slug: ${as.cyan(response.data.slug)}`
+  ).exit("success");
+}
+export {
+  createAction
+};

package/chunks/action-JOSVV6YA.js

@@ -0,0 +1,71 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getFileOrUrl
+} from "./chunk-23I5PKZZ.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/document/lint/action.ts
+import spectralCore from "@stoplight/spectral-core";
+import "@stoplight/spectral-rulesets";
+import as from "ansis";
+
+// src/domains/document/lint/helpers.ts
+import { bundleAndLoadRuleset } from "@stoplight/spectral-ruleset-bundler/with-loader";
+async function loadRuleset(ruleset) {
+  return await bundleAndLoadRuleset("/.spectral.yaml", {
+    fs: {
+      promises: {
+        // @ts-expect-error No need for overloading here.
+        async readFile(_filepath) {
+          return ruleset;
+        }
+      }
+    },
+    format: "esm"
+  });
+}
+var defaultRuleset = `extends: spectral:oas
+rules: {}`;
+var severityToLabel = (severity) => {
+  return {
+    0: "Error",
+    1: "Warning",
+    2: "Information",
+    3: "Hint"
+  }[severity];
+};
+
+// src/domains/document/lint/action.ts
+var { Spectral } = spectralCore;
+async function lintAction(inputArgument, { rule: ruleArgument }) {
+  if (!inputArgument) {
+    return output.error().title("Invalid argument").message("Please provide a file path").exit("error");
+  }
+  const spectral = new Spectral();
+  const specification = await getFileOrUrl(inputArgument);
+  const ruleFileContents = ruleArgument ? await getFileOrUrl(ruleArgument) : defaultRuleset;
+  const ruleset = await loadRuleset(ruleFileContents);
+  spectral.setRuleset(ruleset);
+  const spectralDiagnostics = await spectral.run(specification);
+  const hasErrors = spectralDiagnostics.filter((d) => d.severity === 0).length !== 0;
+  if (!hasErrors) {
+    output.info().message(as.green("\u2714 No issues found!")).print();
+  } else {
+    output.warn().line(as.red("\u2716 Issues found:")).print();
+  }
+  for (const diagnostic of spectralDiagnostics) {
+    output.info().line(`${as.yellow("Rule:")} ${as.bold(diagnostic.code)}`).line(`${as.yellow("Message:")} ${diagnostic.message}`).line(`${as.yellow("Severity:")} ${severityToLabel(diagnostic.severity)}`).line(
+      `${as.yellow("Location:")} ${diagnostic.range.start.line}:${diagnostic.range.start.character} - ${diagnostic.range.end.line}:${diagnostic.range.end.character}`
+    ).line(as.gray("---")).print();
+  }
+  if (hasErrors) {
+    output.error().exit("error");
+  }
+}
+export {
+  lintAction
+};