index.ts

#!/usr/bin/env bun

import { input, search, select } from "@inquirer/prompts";
import { gitmojis, type Gitmoji } from "./gitmojis";

type ConventionalType = {
  value: string;
  name: string;
  description: string;
};

type GitmojiChoice = {
  value: Gitmoji;
  name: string;
  description: string;
  short: string;
};

const conventionalTypes: ConventionalType[] = [
  { value: "feat", name: "feat", description: "A new feature" },
  { value: "fix", name: "fix", description: "A bug fix" },
  { value: "docs", name: "docs", description: "Documentation only changes" },
  { value: "style", name: "style", description: "Formatting changes; no code behavior changes" },
  { value: "refactor", name: "refactor", description: "A code change that neither fixes a bug nor adds a feature" },
  { value: "perf", name: "perf", description: "A code change that improves performance" },
  { value: "test", name: "test", description: "Add or update tests" },
  { value: "build", name: "build", description: "Build system or external dependency changes" },
  { value: "ci", name: "ci", description: "CI configuration and workflow changes" },
  { value: "chore", name: "chore", description: "Other maintenance tasks" },
  { value: "revert", name: "revert", description: "Revert a previous commit" }
];

function buildTypeChoices(): ConventionalType[] {
  return conventionalTypes.map((type) => ({
    value: type.value,
    name: type.name,
    description: type.description
  }));
}

function scoreGitmoji(gitmoji: Gitmoji, term?: string): number {
  if (!term) {
    return 0;
  }

  const query = term.trim().toLowerCase();
  const haystack = [
    gitmoji.emoji,
    gitmoji.code,
    gitmoji.name,
    gitmoji.description
  ].join(" ").toLowerCase();

  if (gitmoji.description.toLowerCase().startsWith(query)) {
    return 4;
  }

  if (gitmoji.code.toLowerCase().includes(query) || gitmoji.name.toLowerCase().includes(query)) {
    return 3;
  }

  if (gitmoji.description.toLowerCase().includes(query)) {
    return 2;
  }

  if (haystack.includes(query)) {
    return 1;
  }

  return -1;
}

function buildGitmojiChoices(term?: string): GitmojiChoice[] {
  return gitmojis
    .map((gitmoji, index) => ({
      gitmoji,
      index,
      score: scoreGitmoji(gitmoji, term)
    }))
    .filter((entry) => entry.score >= 0)
    .sort((left, right) => {
      if (right.score !== left.score) {
        return right.score - left.score;
      }

      return left.index - right.index;
    })
    .map(({ gitmoji }) => ({
      value: gitmoji,
      name: `${gitmoji.emoji}  ${gitmoji.code}`,
      description: gitmoji.description,
      short: `${gitmoji.emoji} ${gitmoji.code}`
    }));
}

function formatCommitMessage(
  type: string,
  gitmoji: Gitmoji,
  scope: string,
  description: string
): string {
  const normalizedScope = scope.trim();
  const normalizedDescription = description.trim();
  const typeWithScope = normalizedScope ? `${type}(${normalizedScope})` : type;

  return `${typeWithScope}: ${gitmoji.emoji} ${normalizedDescription}`;
}

async function main(): Promise<void> {
  const type = await select({
    message: "Select a conventional commit type",
    choices: buildTypeChoices(),
    pageSize: 11
  });

  const selectedGitmoji = await search({
    message: "Select a gitmoji (search by description, code, or name)",
    source: async (term) => buildGitmojiChoices(term),
    pageSize: 10,
    validate: (value) => Boolean(value) || "Select a gitmoji."
  });

  const scope = await input({
    message: "Scope (optional)",
    default: "",
    transformer: (value) => value.trim()
  });

  const description = await input({
    message: "Description",
    validate: (value) => {
      if (!value.trim()) {
        return "Description is required.";
      }

      return true;
    }
  });

  const commitMessage = formatCommitMessage(type, selectedGitmoji, scope, description);

  console.log("");
  console.log(commitMessage);
}

main().catch((error: unknown) => {
  if (error instanceof Error && error.name === "ExitPromptError") {
    process.exit(130);
  }

  console.error(error);
  process.exit(1);
});