@cluerise/tools 3.0.0

package/dist/scripts/create-commit-message/main.js

@@ -0,0 +1,149 @@
+import FileSystem from "fs/promises";
+import { z, ZodError } from "zod";
+import ChildProcess from "child_process";
+import "eslint";
+import "glob";
+import "prettier";
+import loadCommitlintConfig from "@commitlint/load";
+const enginesSchema = z.object({
+  node: z.string()
+});
+const repositoryObjectSchema = z.object({
+  type: z.string(),
+  url: z.string(),
+  directory: z.ostring()
+});
+const repositorySchema = z.union([z.string(), repositoryObjectSchema]);
+z.object({
+  name: z.string(),
+  version: z.string(),
+  description: z.string(),
+  engines: enginesSchema.optional(),
+  repository: repositorySchema.optional()
+});
+const runMain = (main2) => {
+  main2(process.argv.slice(2)).then((exitCode) => {
+    process.exit(exitCode);
+  }).catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+};
+const capitalize = (value) => {
+  const [firstLetter] = value;
+  if (!firstLetter) {
+    return value;
+  }
+  return `${firstLetter.toUpperCase()}${value.slice(1)}`;
+};
+const StringUtils = {
+  capitalize
+};
+const getBranchName = () => ChildProcess.execSync("git symbolic-ref --short HEAD").toString().trim();
+const isRebasing = () => {
+  try {
+    ChildProcess.execSync("ls `git rev-parse --git-dir` | grep rebase");
+    return true;
+  } catch {
+    return false;
+  }
+};
+const GitCommands = {
+  getBranchName,
+  isRebasing
+};
+z.union([z.literal("all"), z.literal("code")]);
+const stringifySemanticCommitMessagePrefix = ({ type, scope }) => `${type}${scope ? `(${scope})` : ""}`;
+const startsWithSemanticCommitMessagePrefix = (message, prefix) => message.startsWith(stringifySemanticCommitMessagePrefix(prefix));
+const createSemanticCommitMessage = (prefix, message) => {
+  const [subject, ...comments] = message.split("\n#");
+  let commitMessage = stringifySemanticCommitMessagePrefix(prefix) + ": ";
+  if (subject) {
+    commitMessage += StringUtils.capitalize(subject);
+  }
+  if (comments.length > 0) {
+    commitMessage += "\n\n#" + comments.join("\n#");
+  }
+  return commitMessage;
+};
+const isValidEnumValue = async (ruleName, value) => {
+  const { rules } = await loadCommitlintConfig();
+  const rule = rules[ruleName];
+  if (!rule) {
+    return true;
+  }
+  const [_severity, _condition, values] = rule;
+  if (!values) {
+    return true;
+  }
+  return values.includes(value);
+};
+const isValidType = (type) => isValidEnumValue("type-enum", type);
+const isValidScope = (scope) => isValidEnumValue("scope-enum", scope);
+const CommitLintConfig = {
+  isValidType,
+  isValidScope
+};
+const parseSemanticBranchName = async (name) => {
+  const [typeValue, scopeValue] = name.split("-");
+  if (!typeValue || !await CommitLintConfig.isValidType(typeValue)) {
+    throw new Error("Invalid commit type in branch name");
+  }
+  const type = typeValue.toLowerCase();
+  const scope = scopeValue && await CommitLintConfig.isValidScope(scopeValue) ? scopeValue.toLowerCase() : null;
+  return {
+    type,
+    scope
+  };
+};
+const parseSemanticCommitMessage = (message) => {
+  const firstColonPosition = message.search(":");
+  const prefix = message.slice(0, firstColonPosition).trim();
+  const content = message.slice(firstColonPosition + 1).trim();
+  return { prefix, content };
+};
+const formatSemanticCommitMessage = (message) => {
+  const { prefix, content } = parseSemanticCommitMessage(message);
+  if (!prefix || !content) {
+    return message;
+  }
+  return `${prefix}: ${StringUtils.capitalize(content)}`;
+};
+const CommitLintCommands = {
+  createSemanticCommitMessage,
+  parseSemanticBranchName,
+  formatSemanticCommitMessage,
+  startsWithSemanticCommitMessagePrefix
+};
+const commitMessagePathArgSchema = z.string();
+const parseCreateCommitMessageArgs = ([commitMessagePathArg]) => {
+  const commitMessagePath = commitMessagePathArgSchema.parse(commitMessagePathArg);
+  return {
+    commitMessagePath
+  };
+};
+const main = async (args) => {
+  try {
+    if (GitCommands.isRebasing()) {
+      return 0;
+    }
+    const { commitMessagePath } = parseCreateCommitMessageArgs(args);
+    const commitMessage = (await FileSystem.readFile(commitMessagePath)).toString();
+    const branchName = GitCommands.getBranchName();
+    const commitMessagePrefix = await CommitLintCommands.parseSemanticBranchName(branchName);
+    if (!CommitLintCommands.startsWithSemanticCommitMessagePrefix(commitMessage, commitMessagePrefix)) {
+      const nextCommitMessage = CommitLintCommands.createSemanticCommitMessage(commitMessagePrefix, commitMessage);
+      await FileSystem.writeFile(commitMessagePath, nextCommitMessage);
+    }
+  } catch (error) {
+    if (error instanceof ZodError) {
+      console.warn("Invalid commit message path");
+    }
+    if (error instanceof Error) {
+      console.warn(error.message);
+    }
+    console.warn(error);
+  }
+  return 0;
+};
+runMain(main);

package/dist/scripts/format-commit-message/main.js

@@ -0,0 +1,130 @@
+import FileSystem from "fs/promises";
+import { z, ZodError } from "zod";
+import "eslint";
+import "glob";
+import "prettier";
+import loadCommitlintConfig from "@commitlint/load";
+const enginesSchema = z.object({
+  node: z.string()
+});
+const repositoryObjectSchema = z.object({
+  type: z.string(),
+  url: z.string(),
+  directory: z.ostring()
+});
+const repositorySchema = z.union([z.string(), repositoryObjectSchema]);
+z.object({
+  name: z.string(),
+  version: z.string(),
+  description: z.string(),
+  engines: enginesSchema.optional(),
+  repository: repositorySchema.optional()
+});
+const runMain = (main2) => {
+  main2(process.argv.slice(2)).then((exitCode) => {
+    process.exit(exitCode);
+  }).catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+};
+const capitalize = (value) => {
+  const [firstLetter] = value;
+  if (!firstLetter) {
+    return value;
+  }
+  return `${firstLetter.toUpperCase()}${value.slice(1)}`;
+};
+const StringUtils = {
+  capitalize
+};
+z.union([z.literal("all"), z.literal("code")]);
+const stringifySemanticCommitMessagePrefix = ({ type, scope }) => `${type}${scope ? `(${scope})` : ""}`;
+const startsWithSemanticCommitMessagePrefix = (message, prefix) => message.startsWith(stringifySemanticCommitMessagePrefix(prefix));
+const createSemanticCommitMessage = (prefix, message) => {
+  const [subject, ...comments] = message.split("\n#");
+  let commitMessage = stringifySemanticCommitMessagePrefix(prefix) + ": ";
+  if (subject) {
+    commitMessage += StringUtils.capitalize(subject);
+  }
+  if (comments.length > 0) {
+    commitMessage += "\n\n#" + comments.join("\n#");
+  }
+  return commitMessage;
+};
+const isValidEnumValue = async (ruleName, value) => {
+  const { rules } = await loadCommitlintConfig();
+  const rule = rules[ruleName];
+  if (!rule) {
+    return true;
+  }
+  const [_severity, _condition, values] = rule;
+  if (!values) {
+    return true;
+  }
+  return values.includes(value);
+};
+const isValidType = (type) => isValidEnumValue("type-enum", type);
+const isValidScope = (scope) => isValidEnumValue("scope-enum", scope);
+const CommitLintConfig = {
+  isValidType,
+  isValidScope
+};
+const parseSemanticBranchName = async (name) => {
+  const [typeValue, scopeValue] = name.split("-");
+  if (!typeValue || !await CommitLintConfig.isValidType(typeValue)) {
+    throw new Error("Invalid commit type in branch name");
+  }
+  const type = typeValue.toLowerCase();
+  const scope = scopeValue && await CommitLintConfig.isValidScope(scopeValue) ? scopeValue.toLowerCase() : null;
+  return {
+    type,
+    scope
+  };
+};
+const parseSemanticCommitMessage = (message) => {
+  const firstColonPosition = message.search(":");
+  const prefix = message.slice(0, firstColonPosition).trim();
+  const content = message.slice(firstColonPosition + 1).trim();
+  return { prefix, content };
+};
+const formatSemanticCommitMessage = (message) => {
+  const { prefix, content } = parseSemanticCommitMessage(message);
+  if (!prefix || !content) {
+    return message;
+  }
+  return `${prefix}: ${StringUtils.capitalize(content)}`;
+};
+const CommitLintCommands = {
+  createSemanticCommitMessage,
+  parseSemanticBranchName,
+  formatSemanticCommitMessage,
+  startsWithSemanticCommitMessagePrefix
+};
+const commitMessagePathArgSchema = z.string();
+const parseFormatCommitMessageArgs = ([commitMessagePathArg]) => {
+  const commitMessagePath = commitMessagePathArgSchema.parse(commitMessagePathArg);
+  return {
+    commitMessagePath
+  };
+};
+const main = async (args) => {
+  try {
+    const { commitMessagePath } = parseFormatCommitMessageArgs(args);
+    const commitMessage = (await FileSystem.readFile(commitMessagePath)).toString();
+    const formattedCommitMessage = CommitLintCommands.formatSemanticCommitMessage(commitMessage);
+    if (formattedCommitMessage !== commitMessage) {
+      await FileSystem.writeFile(commitMessagePath, formattedCommitMessage);
+    }
+  } catch (error) {
+    if (error instanceof ZodError) {
+      console.warn("Invalid commit message path");
+    }
+    if (error instanceof Error) {
+      console.warn(error.message);
+    }
+    console.warn(error);
+  }
+  return 0;
+};
+runMain(main);

package/dist/scripts/init/main.js

@@ -0,0 +1,386 @@
+import { z, ZodError } from "zod";
+import FileSystem from "fs/promises";
+import Path from "path";
+import ChildProcess from "child_process";
+import { ESLint } from "eslint";
+import { glob } from "glob";
+import * as Prettier from "prettier";
+import "@commitlint/load";
+class ParseGitRepositoryError extends Error {
+}
+const gitProviderOrigins = {
+  github: "https://github.com"
+};
+const gitProviderNames = Object.keys(gitProviderOrigins);
+const isGitProviderName = (name) => gitProviderNames.includes(name);
+const parseRepositoryUrl = (urlString) => {
+  const urlValue = urlString.includes(":") ? urlString : `https://${urlString}`;
+  const url = new URL(urlValue);
+  const scheme = url.protocol.slice(0, -1);
+  if (isGitProviderName(scheme)) {
+    const [owner, repositoryName] = url.pathname.split("/");
+    if (!owner || !repositoryName) {
+      throw new ParseGitRepositoryError("Unknown owner or repositoryName");
+    }
+    return {
+      origin: gitProviderOrigins[scheme],
+      owner,
+      repositoryName
+    };
+  }
+  if (scheme === "https") {
+    const [, owner, repositoryName] = url.pathname.split("/");
+    if (!owner || !repositoryName) {
+      throw new ParseGitRepositoryError("Unknown owner or repositoryName");
+    }
+    return {
+      origin: url.origin,
+      owner,
+      repositoryName: repositoryName.endsWith(".git") ? repositoryName.slice(0, -4) : repositoryName
+    };
+  }
+  throw new ParseGitRepositoryError("Unsupported repository URL");
+};
+const parsePackageJsonRepository = (repository) => {
+  if (typeof repository === "string") {
+    return parseRepositoryUrl(repository);
+  }
+  return parseRepositoryUrl(repository.url);
+};
+const enginesSchema = z.object({
+  node: z.string()
+});
+const repositoryObjectSchema = z.object({
+  type: z.string(),
+  url: z.string(),
+  directory: z.ostring()
+});
+const repositorySchema = z.union([z.string(), repositoryObjectSchema]);
+const packageJsonSchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  description: z.string(),
+  engines: enginesSchema.optional(),
+  repository: repositorySchema.optional()
+});
+const readPackageJson = async () => {
+  const packageJsonData = await FileSystem.readFile("package.json", { encoding: "utf8" });
+  const packageJson = JSON.parse(packageJsonData);
+  const parseResult = packageJsonSchema.safeParse(packageJson);
+  if (!parseResult.success) {
+    throw parseResult.error;
+  }
+  return packageJson;
+};
+const CoreCommands = {
+  readPackageJson,
+  parsePackageJsonRepository
+};
+const runMain = (main2) => {
+  main2(process.argv.slice(2)).then((exitCode) => {
+    process.exit(exitCode);
+  }).catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+};
+const createResultMessage = (exitCode) => {
+  if (exitCode === null) {
+    return "Done";
+  }
+  return exitCode === 0 ? "OK" : "Failed";
+};
+const createStatusConsole = (command) => ({
+  printBegin: (arg) => console.info(`${command} ${arg}...`),
+  printEnd: (arg, exitCode = null) => console.info(`${command} ${arg}... ${createResultMessage(exitCode)}`)
+});
+const packageName = "@cluerise/tools";
+const rootAppDirectory = `./node_modules/${packageName}`;
+const toolsConfigPackage = `${packageName}/dist/configs`;
+const toolsConfigDirectory = `${rootAppDirectory}/dist/configs`;
+const AppConfig = {
+  toolsConfigPackage,
+  toolsConfigDirectory
+};
+const copyFile = async (sourceDirectory, filePath, destinationFilePath) => {
+  const sourcePath = Path.resolve(sourceDirectory, filePath);
+  const destinationPath = Path.resolve(process.cwd(), destinationFilePath ?? filePath);
+  await FileSystem.mkdir(Path.dirname(destinationPath), { recursive: true });
+  return FileSystem.copyFile(sourcePath, destinationPath);
+};
+const createFile = async (path, content) => {
+  const destinationPath = Path.resolve(process.cwd(), path);
+  await FileSystem.mkdir(Path.dirname(destinationPath), { recursive: true });
+  return FileSystem.writeFile(destinationPath, content);
+};
+const ConfigCommands = {
+  copyFile,
+  createFile
+};
+const commitlintConfigName = "commitlint.config";
+const commitlintConfigPath = `${commitlintConfigName}.ts`;
+const initCommitlint = async ({ configPackage }) => {
+  const configContent = `export { default } from '${configPackage}/${commitlintConfigName}';
+`;
+  await ConfigCommands.createFile(commitlintConfigPath, configContent);
+};
+const editorConfigPath = ".editorconfig";
+const initEditorConfig = async ({ configDirectory }) => {
+  await ConfigCommands.copyFile(configDirectory, editorConfigPath);
+};
+const eslintConfigPath = ".eslintrc.cjs";
+const eslintIgnorePath = ".eslintignore";
+const initEslint = async ({ configDirectory }) => {
+  const configContent = `module.exports = {
+  extends: '${configDirectory}/${eslintConfigPath}'
+};
+`;
+  await ConfigCommands.createFile(eslintConfigPath, configContent);
+  await ConfigCommands.copyFile(configDirectory, eslintIgnorePath);
+};
+const sourceGitignorePath = "_gitignore";
+const destinationGitignorePath = ".gitignore";
+const gitHookDirectory = "hooks";
+const gitHookPaths = [
+  Path.join(gitHookDirectory, "commit-msg"),
+  Path.join(gitHookDirectory, "post-commit"),
+  Path.join(gitHookDirectory, "pre-commit"),
+  Path.join(gitHookDirectory, "prepare-commit-msg")
+];
+const initGit = async ({ configDirectory }) => {
+  await ConfigCommands.copyFile(configDirectory, sourceGitignorePath, destinationGitignorePath);
+  await Promise.all(gitHookPaths.map((gitHookPath) => ConfigCommands.copyFile(configDirectory, gitHookPath)));
+};
+const lintStagedConfigPath = "lint-staged.config.js";
+const initLintStaged = async ({ configPackage }) => {
+  const configContent = `export { default } from '${configPackage}/${lintStagedConfigPath}';
+`;
+  await ConfigCommands.createFile(lintStagedConfigPath, configContent);
+};
+const sourceNpmrcPath = "_npmrc";
+const destinationNpmrcPath = ".npmrc";
+const initNpm = async ({ configDirectory }) => {
+  await ConfigCommands.copyFile(configDirectory, sourceNpmrcPath, destinationNpmrcPath);
+};
+const nvmrcPath = ".nvmrc";
+const initNvm = async ({ configDirectory }) => {
+  await ConfigCommands.copyFile(configDirectory, nvmrcPath);
+};
+const prettierConfigPath = "prettier.config.js";
+const initPrettier = async ({ configPackage }) => {
+  const configContent = `export { default } from '${configPackage}/${prettierConfigPath}';
+`;
+  await ConfigCommands.createFile(prettierConfigPath, configContent);
+};
+const releaseConfigPath = "release.config.js";
+const defaultReleaseConfigParams = {
+  host: "<host>",
+  owner: "<owner>",
+  repository: "<repository>"
+};
+const getReleaseConfigParams = async () => {
+  try {
+    const { repository } = await CoreCommands.readPackageJson();
+    if (!repository) {
+      return defaultReleaseConfigParams;
+    }
+    const { origin, owner, repositoryName } = CoreCommands.parsePackageJsonRepository(repository);
+    return {
+      host: origin,
+      owner,
+      repository: repositoryName
+    };
+  } catch {
+    return defaultReleaseConfigParams;
+  }
+};
+const initRelease = async ({ configPackage }) => {
+  const releaseConfigParams = await getReleaseConfigParams();
+  const configContent = `import { createReleaseConfig } from '${configPackage}/${releaseConfigPath}';
+
+export default createReleaseConfig(${JSON.stringify(releaseConfigParams, null, 2)});
+`;
+  await ConfigCommands.createFile(releaseConfigPath, configContent);
+};
+const typescriptConfigPath = "tsconfig.json";
+const initTypescript = async ({ configDirectory }) => {
+  const configContent = `{
+  "extends": "${configDirectory}/${typescriptConfigPath}",
+  "compilerOptions": {
+    "baseUrl": "./"
+  }
+}
+`;
+  await ConfigCommands.createFile(typescriptConfigPath, configContent);
+};
+const vscodeSettingsPath = Path.join(".vscode", "settings.json");
+const initVscode = async () => {
+  const configContent = `{
+  "prettier.ignorePath": "node_modules/@cluerise/tools/dist/configs/.prettierignore",
+  "typescript.tsdk": "node_modules/typescript/lib"
+}
+`;
+  await ConfigCommands.createFile(vscodeSettingsPath, configContent);
+};
+const toolInitializers = {
+  commitlint: initCommitlint,
+  editorconfig: initEditorConfig,
+  eslint: initEslint,
+  git: initGit,
+  "lint-staged": initLintStaged,
+  npm: initNpm,
+  nvm: initNvm,
+  prettier: initPrettier,
+  release: initRelease,
+  typescript: initTypescript,
+  vscode: initVscode
+};
+const toolInitializerNames = Object.keys(toolInitializers);
+const toolNameSchema = z.union([
+  z.literal("commitlint"),
+  z.literal("editorconfig"),
+  z.literal("eslint"),
+  z.literal("git"),
+  z.literal("lint-staged"),
+  z.literal("npm"),
+  z.literal("nvm"),
+  z.literal("prettier"),
+  z.literal("release"),
+  z.literal("typescript"),
+  z.literal("vscode")
+]);
+const initializingConsole = createStatusConsole("Initializing");
+const initTool = async (name, params) => {
+  const toolInitializer = toolInitializers[name];
+  if (!toolInitializer) {
+    throw new Error(`Tool "${name}" is not supported.`);
+  }
+  initializingConsole.printBegin(name);
+  await toolInitializer(params);
+  initializingConsole.printEnd(name);
+};
+const initAllTools = async (params) => {
+  for (const name of toolInitializerNames) {
+    await initTool(name, params);
+  }
+};
+const InitCommands = {
+  initAllTools,
+  initTool
+};
+const lintCommit = (args) => {
+  const { status } = ChildProcess.spawnSync("commitlint", args, { stdio: "inherit" });
+  return status ?? 0;
+};
+z.union([z.literal("all"), z.literal("code")]);
+const scopePatterns = {
+  all: ["**"],
+  code: ["src/**"]
+};
+const scopeShortcuts = Object.keys(scopePatterns);
+const isScopeShortcut = (scope) => scopeShortcuts.includes(scope);
+const resolveScope = (scope) => {
+  if (Array.isArray(scope)) {
+    return scope;
+  }
+  if (isScopeShortcut(scope)) {
+    return scopePatterns[scope];
+  }
+  return [scope];
+};
+const formatWithPrettier = async (patterns) => {
+  const eslint = new ESLint();
+  const configPath = await Prettier.resolveConfigFile();
+  if (!configPath) {
+    return false;
+  }
+  const config = await Prettier.resolveConfig(configPath);
+  if (!config) {
+    return false;
+  }
+  const paths = await glob(patterns, {
+    nodir: true,
+    ignore: "node_modules/**"
+  });
+  await Promise.all(
+    paths.map(async (path) => {
+      if (await eslint.isPathIgnored(path)) {
+        return;
+      }
+      const prevContent = (await FileSystem.readFile(path)).toString();
+      const nextContent = await Prettier.format(prevContent, {
+        ...config,
+        filepath: path
+      });
+      await FileSystem.writeFile(path, nextContent);
+    })
+  );
+};
+const lintFiles = async (scope, options) => {
+  const patterns = resolveScope(scope);
+  if (options == null ? void 0 : options.fix) {
+    await formatWithPrettier(patterns);
+  }
+  const eslint = new ESLint({
+    fix: options == null ? void 0 : options.fix
+  });
+  const results = await eslint.lintFiles(patterns);
+  const problemCount = results.reduce((sum, result) => sum + result.errorCount + result.warningCount, 0);
+  if (options == null ? void 0 : options.fix) {
+    await ESLint.outputFixes(results);
+  }
+  if (problemCount > 0) {
+    const formatter = await eslint.loadFormatter("stylish");
+    const resultText = formatter.format(results);
+    console.error(resultText);
+    const errorMessage = `Linting failed with ${problemCount} problem${problemCount === 1 ? "" : "s"}.`;
+    throw new Error(errorMessage);
+  }
+};
+const lintStaged = (args) => {
+  const { status } = ChildProcess.spawnSync("lint-staged", args, { stdio: "inherit" });
+  return status ?? 0;
+};
+const LintCommands = {
+  lintFiles,
+  lintCommit,
+  lintStaged
+};
+const toolNameArgSchema = z.union([z.literal("all"), toolNameSchema]);
+const parseInitArgs = ([nameArg]) => {
+  const name = toolNameArgSchema.parse(nameArg);
+  return {
+    name
+  };
+};
+const toolInitializerParams = {
+  configDirectory: AppConfig.toolsConfigDirectory,
+  configPackage: AppConfig.toolsConfigPackage
+};
+const main = async (args) => {
+  try {
+    const { name } = parseInitArgs(args);
+    if (name === "all") {
+      await InitCommands.initAllTools(toolInitializerParams);
+    } else {
+      await InitCommands.initTool(name, toolInitializerParams);
+    }
+    await LintCommands.lintFiles("all", { fix: true });
+    return 0;
+  } catch (error) {
+    if (error instanceof ZodError) {
+      const firstIssue = error.issues[0];
+      if ((firstIssue == null ? void 0 : firstIssue.code) === "invalid_union") {
+        console.error("Invalid tool name");
+        return 1;
+      }
+    }
+    if (error instanceof Error) {
+      console.error(error.message);
+      return 1;
+    }
+    console.error(error);
+    return 1;
+  }
+};
+runMain(main);