new-branch 0.1.1 → 0.3.0

package/README.md

@@ -119,13 +119,11 @@ Example AST representation:
 
 ## 6. Built-in Variables
 
-Variable Description
-
----
-
-type Branch type (feat, fix, etc.)
-title Human-readable task title
-id Task identifier (e.g., STK-123)
+| Variable | Description                     |
+| -------- | ------------------------------- |
+| type     | Branch type (feat, fix, etc.)   |
+| title    | Human-readable task title       |
+| id       | Task identifier (e.g., STK-123) |
 
 ---
 
@@ -135,28 +133,29 @@ All transforms must be pure functions.
 
 ### 7.1 String Transforms
 
-| Transform \| Description \|
-
-\|------------\|-------------\| slugify \| Converts to URL-safe slug \|
-\| lowercase \| Converts to lowercase \| \| uppercase \| Converts to
-uppercase \| \| trim \| Trims whitespace \| \| titlecase \| Capitalizes
-words \|
+| Transform | Description               |
+| --------- | ------------------------- |
+| slugify   | Converts to URL-safe slug |
+| lowercase | Converts to lowercase     |
+| uppercase | Converts to uppercase     |
+| trim      | Trims whitespace          |
+| titlecase | Capitalizes words         |
 
 ### 7.2 Argument-based Transforms
 
-| Transform \| Description \| Example \|
-
-\|------------\|-------------\|---------\| max \| Truncates string to
-max length \| max:25 \| \| pad \| Pads string to length \| pad:10 \|
+| Transform | Description                    | Example |
+| --------- | ------------------------------ | ------- |
+| max       | Truncates string to max length | max:25  |
+| pad       | Pads string to length          | pad:10  |
 
 ### 7.3 Validation Transforms
 
-Validation transforms do not modify value but throw errors if invalid.
+Validation transforms do not modify a value but throw errors if invalid.
 
-| Transform \| Description \|
-
-\|------------\|-------------\| required \| Ensures value is not empty
-\| \| match \| Validates via regex \|
+| Transform | Description                |
+| --------- | -------------------------- |
+| required  | Ensures value is not empty |
+| match     | Validates value via regex  |
 
 ---
 
@@ -237,12 +236,10 @@ Validation must occur immediately after input.
 
 ## 12. Optional Flags
 
-Flag Description
-
----
-
---create Creates branch using `git switch -c`
---print Prints branch name only (default behavior)
+| Flag       | Description                                |
+| ---------- | ------------------------------------------ |
+| `--create` | Creates branch using `git switch -c`       |
+| `--print`  | Prints branch name only (default behavior) |
 
 ---
 

package/dist/cli.js

@@ -4,6 +4,7 @@ import { parsePattern } from "./pattern/parsePattern.js";
 import { defaultTransforms } from "./pattern/transforms/index.js";
 import { renderPattern } from "./pattern/transforms/renderPattern.js";
 import { resolveMissingValues } from "./runtime/resolveMissingValues.js";
+import { loadProjectConfig } from "./config/loadProjectConfig.js";
 import { sanitizeGitRef } from "./git/sanitizeGitRef.js";
 import { validateBranchName } from "./git/validateBranchName.js";
 import { createBranch } from "./git/createBranch.js";
@@ -47,15 +48,22 @@ function toInitialValues(args) {
 }
 async function run() {
     // Step 0: args/options
+    // Note: CAC prints help, but depending on our parseArgs wrapper we might not
+    // expose `help` in `args.options`. We still want to exit early and never
+    // require a pattern when the user just asked for help.
+    const argv = process.argv.slice(2);
+    const wantsHelp = argv.includes("--help") || argv.includes("-h");
     const args = parseArgs(process.argv);
-    if (args.options.help) {
+    if (wantsHelp) {
         return;
     }
     const quiet = args.options.quiet === true;
     const create = args.options.create === true;
     const prompt = args.options.prompt !== false;
     // Pipeline: pattern -> AST -> resolve values -> render -> sanitize -> validate -> (optional) git -> output
-    const patternRes = requirePattern(args.options.pattern);
+    const projectConfig = await loadProjectConfig();
+    const resolvedPattern = args.options.pattern ?? projectConfig.pattern;
+    const patternRes = requirePattern(resolvedPattern);
     if (!isOk(patternRes))
         fail("Invalid CLI arguments.", patternRes.error);
     const astRes = safe(() => parsePattern(patternRes.value));

package/dist/config/loadProjectConfig.js

@@ -0,0 +1,19 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+export async function loadProjectConfig() {
+    try {
+        const path = join(process.cwd(), "package.json");
+        const raw = await readFile(path, "utf8");
+        const pkg = JSON.parse(raw);
+        const config = pkg["new-branch"];
+        if (!config || typeof config !== "object")
+            return {};
+        const cfg = config;
+        return {
+            pattern: typeof cfg.pattern === "string" ? cfg.pattern : undefined,
+        };
+    }
+    catch {
+        return {};
+    }
+}

package/dist/config/loadProjectConfig.test.js

@@ -0,0 +1,34 @@
+import { vi, describe, it, expect, beforeEach } from "vitest";
+vi.mock("node:fs/promises", () => ({
+    readFile: vi.fn(),
+}));
+import { readFile } from "node:fs/promises";
+describe("loadProjectConfig", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    it("returns pattern when package.json contains new-branch.pattern as string", async () => {
+        readFile.mockResolvedValueOnce(JSON.stringify({ "new-branch": { pattern: "{type}/{title}-{id}" } }));
+        const { loadProjectConfig } = await import("./loadProjectConfig.js");
+        const cfg = await loadProjectConfig();
+        expect(cfg).toEqual({ pattern: "{type}/{title}-{id}" });
+    });
+    it("returns empty object when package.json has no new-branch key", async () => {
+        readFile.mockResolvedValueOnce(JSON.stringify({ name: "pkg" }));
+        const { loadProjectConfig } = await import("./loadProjectConfig.js");
+        const cfg = await loadProjectConfig();
+        expect(cfg).toEqual({});
+    });
+    it("ignores non-string pattern values", async () => {
+        readFile.mockResolvedValueOnce(JSON.stringify({ "new-branch": { pattern: 123 } }));
+        const { loadProjectConfig } = await import("./loadProjectConfig.js");
+        const cfg = await loadProjectConfig();
+        expect(cfg).toEqual({});
+    });
+    it("returns empty object if reading package.json throws", async () => {
+        readFile.mockRejectedValueOnce(new Error("enoent"));
+        const { loadProjectConfig } = await import("./loadProjectConfig.js");
+        const cfg = await loadProjectConfig();
+        expect(cfg).toEqual({});
+    });
+});

package/dist/pattern/transforms/camel.js

@@ -0,0 +1,25 @@
+import { splitWords, upperFirst } from "./helpers/words.js";
+/**
+ * Transform: camel
+ *
+ * Converts an input string into camelCase. Uses `splitWords` to extract word
+ * boundaries and lower-cases the words before joining. The first word is kept
+ * in lower-case; subsequent words are capitalized using `upperFirst`.
+ *
+ * Examples:
+ * - "My Task" -> "myTask"
+ * - "HTTP Server" -> "httpServer"
+ */
+export const camel = {
+    name: "camel",
+    fn: (value) => {
+        const words = splitWords(value).map((w) => w.toLowerCase());
+        if (!words.length)
+            return "";
+        return words[0] + words.slice(1).map(upperFirst).join("");
+    },
+    doc: {
+        summary: "Converts value to camelCase.",
+        usage: ["{title:camel}"],
+    },
+};

package/dist/pattern/transforms/camel.test.js

@@ -0,0 +1,13 @@
+import { describe, it, expect } from "vitest";
+import { camel } from "./camel.js";
+describe("camel transform", () => {
+    it("converts spaced text to camelCase", () => {
+        expect(camel.fn("My Task", [])).toBe("myTask");
+    });
+    it("handles punctuation and multiple separators", () => {
+        expect(camel.fn("hello-world_test", [])).toBe("helloWorldTest");
+    });
+    it("returns empty string for empty input", () => {
+        expect(camel.fn("", [])).toBe("");
+    });
+});

package/dist/pattern/transforms/helpers/words.js

@@ -0,0 +1,64 @@
+/**
+ * Splits an input string into word-like segments.
+ *
+ * The function attempts to be Unicode-aware and supports the following
+ * heuristics for identifying boundaries:
+ * - Splits on any run of non-letter/number characters (spaces, punctuation).
+ * - Inserts boundaries for camelCase (e.g. `myTask` -> `my Task`).
+ * - Inserts a boundary between an ALL-CAPS acronym and a following
+ *   capitalized word (e.g. `HTTPServer` -> `HTTP Server`).
+ *
+ * Returned words are trimmed and empty segments are discarded.
+ *
+ * @example
+ * splitWords("myTask") // => ["my", "Task"]
+ * splitWords("HTTPServer") // => ["HTTP", "Server"]
+ * splitWords("Título grande") // => ["Título", "grande"]
+ *
+ * @param input - The string to split into words.
+ * @returns An array of word segments (possibly empty).
+ */
+export function splitWords(input) {
+    const cleaned = input.trim();
+    if (!cleaned)
+        return [];
+    const withBoundaries = cleaned
+        // camelCase boundary: myTask -> my Task
+        .replace(/(\p{Ll}|\p{N})(\p{Lu})/gu, "$1 $2")
+        // ALLCAPS followed by lowercase: HTTPServer -> HTTP Server
+        .replace(/(\p{Lu})(\p{Lu}\p{Ll})/gu, "$1 $2");
+    return withBoundaries
+        .split(/[^\p{L}\p{N}]+/u)
+        .map((w) => w.trim())
+        .filter(Boolean);
+}
+/**
+ * Upper-cases the first character of the provided string.
+ *
+ * Does not modify the remainder of the string.
+ *
+ * @example
+ * upperFirst("hello") // => "Hello"
+ * upperFirst("") // => ""
+ *
+ * @param s - Input string.
+ * @returns String with the first character upper-cased (if present).
+ */
+export function upperFirst(s) {
+    return s.length ? s[0].toUpperCase() + s.slice(1) : s;
+}
+/**
+ * Lower-cases the first character of the provided string.
+ *
+ * Does not modify the remainder of the string.
+ *
+ * @example
+ * lowerFirst("Hello") // => "hello"
+ * lowerFirst("") // => ""
+ *
+ * @param s - Input string.
+ * @returns String with the first character lower-cased (if present).
+ */
+export function lowerFirst(s) {
+    return s.length ? s[0].toLowerCase() + s.slice(1) : s;
+}

package/dist/pattern/transforms/helpers/words.test.js

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "vitest";
+import { splitWords, upperFirst, lowerFirst } from "./words.js";
+describe("splitWords", () => {
+    it("returns empty array for empty or whitespace-only input", () => {
+        expect(splitWords("")).toEqual([]);
+        expect(splitWords("   ")).toEqual([]);
+    });
+    it("splits on separators and trims words", () => {
+        expect(splitWords("hello world-test")).toEqual(["hello", "world", "test"]);
+        expect(splitWords("  leading  and  trailing  ")).toEqual(["leading", "and", "trailing"]);
+    });
+    it("handles camelCase boundaries", () => {
+        expect(splitWords("myTask")).toEqual(["my", "Task"]);
+        expect(splitWords("version2Beta")).toEqual(["version2", "Beta"]);
+    });
+    it("handles ALLCAPS followed by capitalized word", () => {
+        expect(splitWords("HTTPServer")).toEqual(["HTTP", "Server"]);
+        expect(splitWords("XMLHttpRequest")).toEqual(["XML", "Http", "Request"]);
+    });
+    it("keeps Unicode letters and accents", () => {
+        expect(splitWords("Título grande")).toEqual(["Título", "grande"]);
+    });
+});
+describe("upperFirst / lowerFirst", () => {
+    it("upperFirst capitalizes only the first character", () => {
+        expect(upperFirst("hello")).toBe("Hello");
+        expect(upperFirst("")).toBe("");
+        expect(upperFirst("éclair")).toBe("Éclair");
+    });
+    it("lowerFirst lowercases only the first character", () => {
+        expect(lowerFirst("Hello")).toBe("hello");
+        expect(lowerFirst("")).toBe("");
+        expect(lowerFirst("Éclair")).toBe("éclair");
+    });
+});

package/dist/pattern/transforms/kebab.js

@@ -0,0 +1,19 @@
+import { splitWords } from "./helpers/words.js";
+/**
+ * Transform: kebab
+ *
+ * Converts an input string into kebab-case (lowercased words joined with
+ * hyphens). Uses `splitWords` to determine word boundaries.
+ *
+ * Example: "My Task" -> "my-task"
+ */
+export const kebab = {
+    name: "kebab",
+    fn: (value) => splitWords(value)
+        .map((w) => w.toLowerCase())
+        .join("-"),
+    doc: {
+        summary: "Converts value to kebab-case.",
+        usage: ["{title:kebab}"],
+    },
+};

package/dist/pattern/transforms/kebab.test.js

@@ -0,0 +1,13 @@
+import { describe, it, expect } from "vitest";
+import { kebab } from "./kebab.js";
+describe("kebab transform", () => {
+    it("converts spaced text to kebab-case", () => {
+        expect(kebab.fn("My Task", [])).toBe("my-task");
+    });
+    it("handles camelCase and punctuation", () => {
+        expect(kebab.fn("myTaskHTTP Server", [])).toBe("my-task-http-server");
+    });
+    it("returns empty string for empty input", () => {
+        expect(kebab.fn("", [])).toBe("");
+    });
+});

package/dist/pattern/transforms/snake.js

@@ -0,0 +1,19 @@
+import { splitWords } from "./helpers/words.js";
+/**
+ * Transform: snake
+ *
+ * Converts an input string into snake_case (lowercased words joined with
+ * underscores). Uses `splitWords` to determine boundaries.
+ *
+ * Example: "My Task" -> "my_task"
+ */
+export const snake = {
+    name: "snake",
+    fn: (value) => splitWords(value)
+        .map((w) => w.toLowerCase())
+        .join("_"),
+    doc: {
+        summary: "Converts value to snake_case.",
+        usage: ["{title:snake}"],
+    },
+};

package/dist/pattern/transforms/snake.test.js

@@ -0,0 +1,13 @@
+import { describe, it, expect } from "vitest";
+import { snake } from "./snake.js";
+describe("snake transform", () => {
+    it("converts spaced text to snake_case", () => {
+        expect(snake.fn("My Task", [])).toBe("my_task");
+    });
+    it("handles camelCase and punctuation", () => {
+        expect(snake.fn("myTaskHTTP Server", [])).toBe("my_task_http_server");
+    });
+    it("returns empty string for empty input", () => {
+        expect(snake.fn("", [])).toBe("");
+    });
+});

package/dist/pattern/transforms/title.js

@@ -0,0 +1,19 @@
+import { splitWords, upperFirst } from "./helpers/words.js";
+/**
+ * Transform: title
+ *
+ * Converts an input string into Title Case where each word's first
+ * character is upper-cased and the remainder lower-cased. Uses `splitWords`.
+ *
+ * Example: "hello WORLD" -> "Hello World"
+ */
+export const title = {
+    name: "title",
+    fn: (value) => splitWords(value)
+        .map((w) => upperFirst(w.toLowerCase()))
+        .join(" "),
+    doc: {
+        summary: "Converts value to Title Case.",
+        usage: ["{title:title}"],
+    },
+};

package/dist/pattern/transforms/title.test.js

@@ -0,0 +1,13 @@
+import { describe, it, expect } from "vitest";
+import { title } from "./title.js";
+describe("title transform", () => {
+    it("converts text to Title Case", () => {
+        expect(title.fn("hello WORLD", [])).toBe("Hello World");
+    });
+    it("handles punctuation and multiple separators", () => {
+        expect(title.fn("my-task_HTTP server", [])).toBe("My Task Http Server");
+    });
+    it("returns empty string for empty input", () => {
+        expect(title.fn("", [])).toBe("");
+    });
+});

package/dist/pattern/transforms/words.js

@@ -0,0 +1,27 @@
+import { splitWords } from "./helpers/words.js";
+/**
+ * Transform: words
+ *
+ * Limits the input to at most `n` words. The transform expects a single
+ * numeric argument that indicates the maximum number of words to keep. The
+ * returned value is the first `n` words joined by a single space.
+ *
+ * Examples:
+ * - `{title:words:2}` applied to "My big title" -> "My big"
+ *
+ * @throws If the provided argument is missing or not a non-negative number.
+ */
+export const words = {
+    name: "words",
+    fn: (value, [n]) => {
+        const count = Number(n);
+        if (!Number.isFinite(count) || count < 0) {
+            throw new Error(`words expects a non-negative number, got "${n ?? ""}"`);
+        }
+        return splitWords(value).slice(0, count).join(" ");
+    },
+    doc: {
+        summary: "Limits value to a maximum number of words.",
+        usage: ["{title:words:3}"],
+    },
+};

package/dist/pattern/transforms/words.test.js

@@ -0,0 +1,16 @@
+import { describe, it, expect } from "vitest";
+import { words } from "./words.js";
+describe("words transform", () => {
+    it("limits the number of words when a positive number is provided", () => {
+        expect(words.fn("one two three four", ["2"]).trim()).toBe("one two");
+        expect(words.fn("hello world", ["5"]).trim()).toBe("hello world");
+    });
+    it("returns empty string when 0 is provided", () => {
+        expect(words.fn("some text here", ["0"]).trim()).toBe("");
+    });
+    it("throws when argument is missing or invalid", () => {
+        expect(() => words.fn("a b c", [])).toThrow();
+        expect(() => words.fn("a b c", ["-1"])).toThrow();
+        expect(() => words.fn("a b c", ["not-a-number"])).toThrow();
+    });
+});

package/dist/runtime/enums.js

@@ -0,0 +1,11 @@
+export const TYPE_CHOICES = [
+    { name: "Feature", value: "feat" },
+    { name: "Fix", value: "fix" },
+    { name: "Documentation", value: "docs" },
+    { name: "Chore", value: "chore" },
+    { name: "Refactor", value: "refactor" },
+    { name: "Test", value: "test" },
+    { name: "Performance", value: "perf" },
+    { name: "Build", value: "build" },
+    { name: "CI", value: "ci" },
+];

package/dist/runtime/resolveMissingValues.js

@@ -1,19 +1,53 @@
-import { input } from "@inquirer/prompts";
+import { input, select } from "@inquirer/prompts";
+import { TYPE_CHOICES } from "../runtime/enums.js";
 /**
- * Resolves missing variable values required by the pattern.
+ * Resolves missing variable values required by a parsed pattern.
  *
- * Rule (v1):
- * - Any variable used in the pattern is considered required.
+ * The function inspects `parsed.variablesUsed` and ensures each required
+ * variable has a non-empty value in the returned object. If a variable is
+ * missing or contains only whitespace and `opts.prompt` is `true`, the
+ * function will prompt the user for the value. The special variable name
+ * `type` is resolved with a select prompt pre-populated with
+ * {@link TYPE_CHOICES}.
+ *
+ * Behavior summary:
+ * - Any variable present in `parsed.variablesUsed` is considered required.
+ * - If a value exists and is non-empty (after trimming) it is preserved.
+ * - If a value is missing or blank and `opts.prompt` is `false`, an error is
+ *   thrown listing the missing variable.
+ * - If `opts.prompt` is `true`, the function will:
+ *   - use a select prompt for the variable named `type` (choices from
+ *     {@link TYPE_CHOICES});
+ *   - use a text input prompt for any other variable.
+ *
+ * @param parsed - Parsed pattern containing `variablesUsed`.
+ * @param initialValues - Existing values that may satisfy requirements.
+ * @param opts - Options controlling prompting behavior.
+ * @returns A promise resolving to a `RenderValues` object containing all
+ * required variables (original values preserved when present).
+ * @throws When a required variable is missing and `opts.prompt` is false.
+ * @example
+ * const parsed = parsePattern('{type}/{title}');
+ * await resolveMissingValues(parsed, { title: 'Hello' }, { prompt: true });
  */
 export async function resolveMissingValues(parsed, initialValues, opts) {
     const requiredVars = parsed.variablesUsed;
     const values = { ...initialValues };
     for (const name of requiredVars) {
-        if (values[name])
+        const current = values[name];
+        if (current && current.trim() !== "")
             continue;
         if (!opts.prompt) {
             throw new Error(`Missing required value: "${name}"`);
         }
+        if (name === "type") {
+            const selected = await select({
+                message: "Select branch type:",
+                choices: TYPE_CHOICES,
+            });
+            values[name] = selected;
+            continue;
+        }
         const answer = await input({
             message: `Enter ${name}:`,
             validate: (v) => (v.trim() ? true : `${name} cannot be empty`),

package/dist/runtime/resolveMissingValues.test.js

@@ -0,0 +1,64 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { resolveMissingValues } from "./resolveMissingValues.js";
+import { parsePattern } from "../pattern/parsePattern.js";
+// Mock prompts module so tests can control interactive behavior
+vi.mock("@inquirer/prompts", () => {
+    return {
+        input: vi.fn(),
+        select: vi.fn(),
+    };
+});
+// Provide a lightweight mock for the runtime enums so module resolution
+// does not fail in the test environment (we only need the shape used
+// by the code under test).
+vi.mock("@/runtime/enums.js", () => ({
+    TYPE_CHOICES: [
+        { name: "Feature", value: "feat" },
+        { name: "Fix", value: "fix" },
+    ],
+}));
+import { input, select } from "@inquirer/prompts";
+beforeEach(() => {
+    // resetAllMocks clears implementations and mock queues (e.g. mockResolvedValueOnce)
+    // which prevents cross-test leakage of one-off mock return values.
+    vi.resetAllMocks();
+});
+describe("resolveMissingValues", () => {
+    it("returns values unchanged when all required vars are present", async () => {
+        const parsed = parsePattern("{type}/{title}-{id}");
+        const initial = { type: "feat", title: "My Task", id: "123" };
+        const out = await resolveMissingValues(parsed, initial, { prompt: true });
+        expect(out).toEqual(initial);
+        expect(input).not.toHaveBeenCalled();
+        expect(select).not.toHaveBeenCalled();
+    });
+    it("prompts for a missing non-type variable using input", async () => {
+        const parsed = parsePattern("{type}/{title}");
+        // input should be used for `title`
+        input.mockResolvedValueOnce("Provided Title");
+        // Type is present so select should not be called
+        const out = await resolveMissingValues(parsed, { type: "fix" }, { prompt: true });
+        expect(input).toHaveBeenCalled();
+        expect(select).not.toHaveBeenCalled();
+        expect(out.title).toBe("Provided Title");
+    });
+    it("uses select for the `type` variable", async () => {
+        const parsed = parsePattern("{type}/{title}");
+        select.mockResolvedValueOnce("feat");
+        input.mockResolvedValueOnce("Some title");
+        const out = await resolveMissingValues(parsed, { title: "Some title" }, { prompt: true });
+        expect(select).toHaveBeenCalled();
+        expect(out.type).toBe("feat");
+    });
+    it("throws when prompt is false and a required variable is missing", async () => {
+        const parsed = parsePattern("{id}");
+        await expect(resolveMissingValues(parsed, {}, { prompt: false })).rejects.toThrow(/Missing required value/i);
+    });
+    it("treats whitespace-only values as missing and prompts", async () => {
+        const parsed = parsePattern("{title}");
+        input.mockResolvedValueOnce("Trimmed");
+        const out = await resolveMissingValues(parsed, { title: "   " }, { prompt: true });
+        expect(input).toHaveBeenCalled();
+        expect(out.title).toBe("Trimmed");
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "new-branch",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Generate and create standardized git branch names from a pattern.",
   "keywords": [
     "git",
@@ -18,8 +18,9 @@
     "start": "node dist/cli.js",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "prepack": "pnpm build && pnpm test:run",
-    "test": "vitest",
-    "test:run": "vitest run",
+    "test": "vitest --dir src --exclude **/dist/**",
+    "test:run": "vitest run --dir src --exclude **/dist/**",
+    "test:coverage": "vitest run --coverage --dir src --exclude **/dist/**",
     "format": "prettier . --write",
     "format:check": "prettier . --check",
     "lint": "eslint src --ext .ts"
@@ -40,11 +41,15 @@
   "bugs": {
     "url": "https://github.com/teles/new-branch/issues"
   },
+  "new-branch": {
+    "pattern": "{type}/{title:lower}-{id}"
+  },
   "homepage": "https://github.com/teles/new-branch#readme",
   "packageManager": "pnpm@10.22.0",
   "devDependencies": {
     "@eslint/js": "10.0.1",
     "@types/node": "25.2.3",
+    "@vitest/coverage-v8": "4.0.18",
     "eslint": "10.0.0",
     "prettier": "3.8.1",
     "tsc-alias": "1.8.16",