better-commits 1.19.1 → 1.20.0-cli-flags

package/src/utils/infer.ts

@@ -0,0 +1,114 @@
+import { execSync } from "child_process";
+import { flags } from "../args";
+import { InferOutput } from "valibot";
+import { Config } from "../valibot-state";
+
+type PrependHashtag = "Never" | "Always" | "Prompt";
+
+const REGEX_SLASH_TAG = /\/(\w+-\d+)/;
+const REGEX_START_TAG = /^(\w+-\d+)/;
+const REGEX_START_UND = /^([A-Z]+-[\[a-zA-Z\]\d]+)_/;
+const REGEX_SLASH_UND = /\/([A-Z]+-[\[a-zA-Z\]\d]+)_/;
+const REGEX_SLASH_NUM = /\/(\d+)/;
+const REGEX_START_NUM = /^(\d+)/;
+
+// TODO: Hypothetically, we could just do this, then remove code from prompts?
+export function infer_not_interactive(config: InferOutput<typeof Config>) {
+  if (flags.interactive) return;
+
+  let inferred_state = { ticket: "", type: "" };
+
+  if (config.check_ticket.infer_ticket) {
+    const inferred_ticket = infer_ticket_from_git(
+      {
+        append_hashtag: config.check_ticket.append_hashtag,
+        prepend_hashtag: config.check_ticket.prepend_hashtag,
+      },
+      flags.git_args,
+    );
+    inferred_state.ticket = inferred_ticket;
+  }
+
+  const inferred_type = infer_type_from_git(
+    config.commit_type.options,
+    flags.git_args,
+  );
+  inferred_state.type = inferred_type;
+
+  return inferred_state;
+}
+
+export function infer_type_from_git(
+  options: { value: string }[],
+  git_args: string,
+): string {
+  const branch = get_current_branch(git_args);
+  if (!branch) return "";
+
+  return infer_type_from_branch(
+    branch,
+    options.map((option) => option.value),
+  );
+}
+
+export function infer_ticket_from_git(
+  options: { append_hashtag: boolean; prepend_hashtag: PrependHashtag },
+  git_args: string,
+): string {
+  const branch = get_current_branch(git_args);
+  if (!branch) return "";
+
+  return infer_ticket_from_branch(branch, options);
+}
+
+function infer_ticket_from_branch(
+  branch: string,
+  options: { append_hashtag: boolean; prepend_hashtag: PrependHashtag },
+): string {
+  const found: string[] = [
+    branch.match(REGEX_START_UND),
+    branch.match(REGEX_SLASH_UND),
+    branch.match(REGEX_SLASH_TAG),
+    branch.match(REGEX_SLASH_NUM),
+    branch.match(REGEX_START_TAG),
+    branch.match(REGEX_START_NUM),
+  ]
+    .filter((value) => value != null)
+    .map((value) => (value && value.length >= 2 ? value[1] : ""));
+
+  if (!found.length || !found[0]) return "";
+
+  return options.append_hashtag || options.prepend_hashtag === "Always"
+    ? `#${found[0]}`
+    : found[0];
+}
+
+function infer_type_from_branch(branch: string, types: string[]): string {
+  const found = types.find((type) => {
+    const start_dash = new RegExp(`^${type}-`);
+    const between_dash = new RegExp(`-${type}-`);
+    const before_slash = new RegExp(`${type}/`);
+
+    const matches = [
+      branch.match(start_dash),
+      branch.match(between_dash),
+      branch.match(before_slash),
+    ].filter((value) => value != null);
+
+    return matches.length > 0;
+  });
+
+  return found ?? "";
+}
+
+function get_current_branch(git_args: string): string {
+  try {
+    return execSync(`git ${git_args} branch --show-current`, {
+      stdio: "pipe",
+    })
+      .toString()
+      .trim();
+  } catch {
+    return "";
+  }
+}

package/src/utils/messages.ts

@@ -0,0 +1,25 @@
+import color from "picocolors";
+
+export function cache_message(message: string): string {
+  return `${message} ${color.dim("· restored from cache")}`;
+}
+
+export function inferred_message(message: string): string {
+  return `${message} ${color.dim("· inferred from branch")}`;
+}
+
+export function optional_message(message: string): string {
+  return `${message} ${color.dim("· optional")}`;
+}
+
+export function space_to_select_message(message: string): string {
+  return `${message} ${color.dim("· <space> to select")}`;
+}
+
+export function a_for_all_message(message: string): string {
+  return `${message} ${color.dim("· <space> to select | <a> to select all")}`;
+}
+
+export function dry_run_message(message: string): string {
+  return `${message} ${color.dim("· dry run - changes will not be committed")}`;
+}

package/src/utils/no-interactive-branch-validation.test.ts

@@ -0,0 +1,170 @@
+import { describe, expect, it } from "vitest";
+import { parse } from "valibot";
+import { BranchState, Config } from "../valibot-state";
+import { create_strict_branch_state } from "./no-interactive-validation";
+
+function make_config(input: Record<string, unknown> = {}) {
+  return parse(Config, input);
+}
+
+function make_state(input: Record<string, unknown>) {
+  return parse(BranchState, input);
+}
+
+describe("create_strict_branch_state", () => {
+  it("accepts valid parsed branch state input", () => {
+    const config = make_config();
+    const schema = create_strict_branch_state(config);
+
+    const result = parse(
+      schema,
+      make_state({
+        type: "feat",
+        description: "add-parser",
+      }),
+    );
+
+    expect(result.type).toBe("feat");
+    expect(result.description).toBe("add-parser");
+  });
+
+  it('defaults checkout to "branch" when omitted', () => {
+    const config = make_config();
+    const schema = create_strict_branch_state(config);
+
+    const result = parse(
+      schema,
+      make_state({
+        type: "feat",
+        description: "add-parser",
+      }),
+    );
+
+    expect(result.checkout).toBe("branch");
+  });
+
+  it("rejects types that are not in config.commit_type.options", () => {
+    const config = make_config();
+    const schema = create_strict_branch_state(config);
+
+    expect(() =>
+      parse(
+        schema,
+        make_state({
+          type: "unknown",
+          description: "add-parser",
+        }),
+      ),
+    ).toThrow(/Invalid --type "unknown"/);
+  });
+
+  it("rejects missing descriptions", () => {
+    const config = make_config();
+    const schema = create_strict_branch_state(config);
+
+    expect(() =>
+      parse(
+        schema,
+        make_state({
+          type: "feat",
+        }),
+      ),
+    ).toThrow(/Missing --description/);
+  });
+
+  it("rejects descriptions that exceed branch_description.max_length", () => {
+    const config = make_config({
+      branch_description: {
+        max_length: 5,
+      },
+    });
+    const schema = create_strict_branch_state(config);
+
+    expect(() =>
+      parse(
+        schema,
+        make_state({
+          type: "feat",
+          description: "too-long",
+        }),
+      ),
+    ).toThrow(/Description exceeds max length/);
+  });
+
+  it("rejects missing ticket when branch_ticket.required is enabled", () => {
+    const config = make_config({
+      branch_ticket: {
+        required: true,
+      },
+    });
+    const schema = create_strict_branch_state(config);
+
+    expect(() =>
+      parse(
+        schema,
+        make_state({
+          type: "feat",
+          description: "add-parser",
+        }),
+      ),
+    ).toThrow(/Missing --ticket/);
+  });
+
+  it("rejects missing version when branch_version.required is enabled", () => {
+    const config = make_config({
+      branch_version: {
+        required: true,
+      },
+    });
+    const schema = create_strict_branch_state(config);
+
+    expect(() =>
+      parse(
+        schema,
+        make_state({
+          type: "feat",
+          description: "add-parser",
+        }),
+      ),
+    ).toThrow(/Missing --branch-version/);
+  });
+
+  it("rejects missing user when branch_user.required is enabled", () => {
+    const config = make_config({
+      branch_user: {
+        required: true,
+      },
+    });
+    const schema = create_strict_branch_state(config);
+
+    expect(() =>
+      parse(
+        schema,
+        make_state({
+          type: "feat",
+          description: "add-parser",
+        }),
+      ),
+    ).toThrow(/Missing --user/);
+  });
+
+  it("allows worktree checkout even when worktrees are disabled", () => {
+    const config = make_config({
+      worktrees: {
+        enable: false,
+      },
+    });
+    const schema = create_strict_branch_state(config);
+
+    const result = parse(
+      schema,
+      make_state({
+        type: "feat",
+        description: "add-parser",
+        checkout: "worktree",
+      }),
+    );
+
+    expect(result.checkout).toBe("worktree");
+  });
+});

package/src/utils/no-interactive-validation.test.ts

@@ -0,0 +1,174 @@
+import { describe, expect, it } from "vitest";
+import { parse } from "valibot";
+import { CommitState, Config } from "../valibot-state";
+import { create_strict_commit_state } from "./no-interactive-validation";
+
+function make_config(input: Record<string, unknown> = {}) {
+  return parse(Config, input);
+}
+
+function make_state(input: Record<string, unknown>) {
+  return parse(CommitState, input);
+}
+
+describe("create_strict_commit_state", () => {
+  it("accepts valid parsed commit state input", () => {
+    const config = make_config();
+    const schema = create_strict_commit_state(config);
+
+    const result = parse(
+      schema,
+      make_state({
+        type: "feat",
+        title: "add parser",
+      }),
+    );
+
+    expect(result.type).toBe("feat");
+    expect(result.title).toBe("add parser");
+  });
+
+  it("rejects types that are not in config.commit_type.options", () => {
+    const config = make_config();
+    const schema = create_strict_commit_state(config);
+
+    expect(() =>
+      parse(
+        schema,
+        make_state({
+          type: "unknown",
+          title: "add parser",
+        }),
+      ),
+    ).toThrow(/Invalid --type "unknown"/);
+  });
+
+  it("allows custom scopes when custom_scope is enabled", () => {
+    const config = make_config({
+      commit_scope: {
+        custom_scope: true,
+        initial_value: "custom",
+        options: [{ value: "app", label: "app" }],
+      },
+    });
+    const schema = create_strict_commit_state(config);
+
+    const result = parse(
+      schema,
+      make_state({
+        type: "feat",
+        scope: "custom-auth",
+        title: "add parser",
+      }),
+    );
+
+    expect(result.scope).toBe("custom-auth");
+  });
+
+  it("rejects scopes outside configured options when custom_scope is disabled", () => {
+    const config = make_config({
+      commit_scope: {
+        custom_scope: false,
+        options: [{ value: "app", label: "app" }],
+      },
+    });
+    const schema = create_strict_commit_state(config);
+
+    expect(() =>
+      parse(
+        schema,
+        make_state({
+          type: "feat",
+          scope: "custom-auth",
+          title: "add parser",
+        }),
+      ),
+    ).toThrow(/Invalid --scope "custom-auth"/);
+  });
+
+  it("rejects missing body when commit_body.required is enabled", () => {
+    const config = make_config({
+      commit_body: {
+        required: true,
+      },
+    });
+    const schema = create_strict_commit_state(config);
+
+    expect(() =>
+      parse(
+        schema,
+        make_state({
+          type: "feat",
+          title: "add parser",
+        }),
+      ),
+    ).toThrow(/Missing --body/);
+  });
+
+  it("rejects titles that exceed commit_title.max_size", () => {
+    const config = make_config({
+      commit_title: {
+        max_size: 10,
+      },
+    });
+    const schema = create_strict_commit_state(config);
+
+    expect(() =>
+      parse(
+        schema,
+        make_state({
+          type: "feat",
+          title: "too long title",
+        }),
+      ),
+    ).toThrow(/Title exceeds max width/);
+  });
+
+  it("rejects closes footers without a ticket", () => {
+    const config = make_config();
+    const schema = create_strict_commit_state(config);
+
+    expect(() =>
+      parse(
+        schema,
+        make_state({
+          type: "feat",
+          title: "add parser",
+          closes: "Closes:",
+        }),
+      ),
+    ).toThrow(/--closes requires --ticket/);
+  });
+
+  it("rejects breaking bodies without breaking titles", () => {
+    const config = make_config();
+    const schema = create_strict_commit_state(config);
+
+    expect(() =>
+      parse(
+        schema,
+        make_state({
+          type: "feat",
+          title: "add parser",
+          breaking_body: "migration needed",
+        }),
+      ),
+    ).toThrow(/--breaking-body requires --breaking-title/);
+  });
+
+  it("rejects deprecates bodies without deprecates titles", () => {
+    const config = make_config();
+    const schema = create_strict_commit_state(config);
+
+    expect(() =>
+      parse(
+        schema,
+        make_state({
+          type: "feat",
+          title: "add parser",
+          deprecates_body: "use the new api",
+        }),
+      ),
+    ).toThrow(/--deprecates-body requires --deprecates-title/);
+  });
+});

package/src/utils/no-interactive-validation.ts

@@ -0,0 +1,190 @@
+import * as v from "valibot";
+import {
+  BRANCH_STATE_ENTRIES,
+  COMMIT_STATE_ENTRIES,
+  Config,
+} from "../valibot-state";
+import { get_commit_title_size } from "./commit-title-size";
+
+function format_allowed_values(values: string[]): string {
+  const printable_values = values.map((value) =>
+    value === "" ? '"" (none)' : `"${value}"`,
+  );
+  return printable_values.join(", ");
+}
+
+export function create_strict_commit_state(
+  config: v.InferOutput<typeof Config>,
+) {
+  const type_values = config.commit_type.options.map((option) => option.value);
+  const scope_values = config.commit_scope.options.map(
+    (option) => option.value,
+  );
+
+  return v.pipe(
+    v.object(COMMIT_STATE_ENTRIES),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (!dataset.typed) return;
+
+      const received = dataset.value.type ? `"${dataset.value.type}"` : "(empty)";
+      if (dataset.value.type && !type_values.includes(dataset.value.type)) {
+        addIssue({
+          message: `Invalid --type ${received}. Valid types: ${format_allowed_values(type_values)}.`,
+        });
+      }
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (!dataset.typed) return;
+
+      const received = dataset.value.scope
+        ? `"${dataset.value.scope}"`
+        : "(empty)";
+
+      if (
+        dataset.value.scope &&
+        !config.commit_scope.custom_scope &&
+        !scope_values.includes(dataset.value.scope)
+      ) {
+        addIssue({
+          message: `Invalid --scope ${received}. Valid scopes: ${format_allowed_values(scope_values)}.`,
+        });
+      }
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (!dataset.typed || dataset.value.title.trim()) return;
+
+      addIssue({
+        message: "Missing --title. Provide a non-empty commit title.",
+      });
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (!dataset.typed) return;
+
+      const size = get_commit_title_size(dataset.value, {
+        include_ticket: config.check_ticket.add_to_title,
+      });
+
+      if (size > config.commit_title.max_size) {
+        addIssue({
+          message: `Title exceeds max width. Current size is ${size}, max is ${config.commit_title.max_size} (includes type, scope, and ticket when enabled).`,
+        });
+      }
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (
+        dataset.typed &&
+        config.commit_body.required &&
+        !dataset.value.body.trim()
+      ) {
+        addIssue({
+          message: "Missing --body. commit_body.required is enabled in config.",
+        });
+      }
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (dataset.typed && dataset.value.closes && !dataset.value.ticket) {
+        addIssue({
+          message:
+            'Invalid footer values: --closes requires --ticket (for example: --ticket "ABC-123").',
+        });
+      }
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (
+        dataset.typed &&
+        dataset.value.breaking_body &&
+        !dataset.value.breaking_title
+      ) {
+        addIssue({
+          message:
+            "Invalid breaking change values: --breaking-body requires --breaking-title.",
+        });
+      }
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (
+        dataset.typed &&
+        dataset.value.deprecates_body &&
+        !dataset.value.deprecates_title
+      ) {
+        addIssue({
+          message:
+            "Invalid deprecation values: --deprecates-body requires --deprecates-title.",
+        });
+      }
+    }),
+  );
+}
+
+export function create_strict_branch_state(
+  config: v.InferOutput<typeof Config>,
+) {
+  const type_values = config.commit_type.options.map((option) => option.value);
+
+  return v.pipe(
+    v.object(BRANCH_STATE_ENTRIES),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (!dataset.typed) return;
+
+      const received = dataset.value.type ? `"${dataset.value.type}"` : "(empty)";
+      if (dataset.value.type && !type_values.includes(dataset.value.type)) {
+        addIssue({
+          message: `Invalid --type ${received}. Valid types: ${format_allowed_values(type_values)}.`,
+        });
+      }
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (!dataset.typed || dataset.value.description.trim()) return;
+
+      addIssue({
+        message:
+          "Missing --description. Provide a non-empty branch description.",
+      });
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (!dataset.typed) return;
+
+      const description = dataset.value.description.trim();
+      if (description.length > config.branch_description.max_length) {
+        addIssue({
+          message: `Description exceeds max length. Current length is ${description.length}, max is ${config.branch_description.max_length}.`,
+        });
+      }
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (
+        dataset.typed &&
+        config.branch_user.required &&
+        !dataset.value.user.trim()
+      ) {
+        addIssue({
+          message: "Missing --user. branch_user.required is enabled in config.",
+        });
+      }
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (
+        dataset.typed &&
+        config.branch_ticket.required &&
+        !dataset.value.ticket.trim()
+      ) {
+        addIssue({
+          message:
+            "Missing --ticket. branch_ticket.required is enabled in config.",
+        });
+      }
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (
+        dataset.typed &&
+        config.branch_version.required &&
+        !dataset.value.version.trim()
+      ) {
+        addIssue({
+          message:
+            "Missing --branch-version. branch_version.required is enabled in config.",
+        });
+      }
+    }),
+  );
+}