new-branch 0.3.0 → 0.3.1

package/README.md

@@ -1,299 +1,24 @@
-# new-branch CLI --- Specification
-
-## 1. Overview
-
-`new-branch` is a CLI tool for generating standardized Git branch names
-based on a configurable pattern and optional interactive prompts.
-
-It can be executed in two ways:
-
-```bash
-npx new-branch
-git nb
-```
-
----
-
-## 2. Goals
-
-- Standardize branch naming across teams.
-- Provide interactive and non-interactive modes.
-- Support a composable transformation pipeline (functional style).
-- Ensure generated names are always valid Git references.
-- Be easily extensible via custom transforms.
-
----
-
-## 3. Usage
-
-### 3.1 Basic
-
-```bash
-npx new-branch
-```
-
-Runs in interactive mode if required fields are missing.
-
----
-
-### 3.2 With config file
-
-```bash
-npx new-branch --config .newbranchrc
-```
-
-Alias:
-
-```bash
-npx new-branch -c .newbranchrc
-```
-
----
-
-### 3.3 With custom pattern
-
-```bash
-npx new-branch --pattern "{type}/{title:slugify;max:25}-{id}"
-```
-
-Alias:
-
-```bash
-npx new-branch -p "{type}/{title:slugify;max:25}-{id}"
-```
-
----
-
-### 3.4 Non-interactive mode
-
-```bash
-npx new-branch   --pattern "{type}/{title:slugify;max:25}-{id}"   --id STK-123   --title "My very interesting task"   --type feat
-```
-
-If all required variables are provided, no prompt is shown.
-
----
-
-## 4. Configuration Precedence
-
-Resolution order (highest priority first):
-
-1.  CLI flags
-2.  Environment variables
-3.  Config file (.newbranchrc)
-4.  Defaults
-5.  Interactive prompt (only if required values are missing)
-
----
-
-## 5. Pattern Language
-
-### 5.1 Syntax
-
-Pattern example:
-
-    {type}/{title:slugify;max:25}-{id}
-
-Structure:
-
-    {variable:transform1;transform2;transformWithArg:arg}
-
-### 5.2 Parsing Model
-
-Each token is parsed into:
-
-- variable name
-- ordered list of transforms
-- optional arguments per transform
-
-Example AST representation:
-
-```json
-{
-  "variable": "title",
-  "pipeline": [{ "fn": "slugify" }, { "fn": "max", "args": [25] }]
-}
-```
-
----
-
-## 6. Built-in Variables
-
-| Variable | Description                     |
-| -------- | ------------------------------- |
-| type     | Branch type (feat, fix, etc.)   |
-| title    | Human-readable task title       |
-| id       | Task identifier (e.g., STK-123) |
-
----
-
-## 7. Built-in Transforms
-
-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         |
-
-### 7.2 Argument-based Transforms
-
-| 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 a value but throw errors if invalid.
-
-| Transform | Description                |
-| --------- | -------------------------- |
-| required  | Ensures value is not empty |
-| match     | Validates value via regex  |
-
----
-
-## 8. Functional Pipeline Execution
-
-Each variable pipeline is executed using reduce semantics:
-
-```js
-pipeline.reduce((acc, step) => {
-  return transforms[step.fn](acc, ...step.args);
-}, baseValue);
-```
-
-All transforms must be registered in a dictionary:
-
-```js
-const transforms = {
-  slugify,
-  lowercase,
-  uppercase,
-  max,
-  trim,
-};
-```
-
----
-
-## 9. Git Ref Sanitization
-
-After full pattern rendering, a final sanitization step must run:
-
-- Remove invalid Git characters
-- Prevent:
-  - trailing slash
-  - double dots
-  - leading dash
-  - spaces
-- Ensure valid Git ref format
-
-Final step example:
-
-```js
-branchName = sanitizeGitRef(branchName);
-```
-
----
-
-## 10. Branch Type Standardization
-
-Supported types:
-
-- feat
-- fix
-- chore
-- docs
-- refactor
-- test
-- perf
-- build
-- ci
-
-Optional alias mapping:
-
-- feature → feat
-- bugfix → fix
-
----
-
-## 11. Interactive Mode Behavior
-
-If required values are missing:
-
-Prompt user for: - type - id - title
-
-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) |
-
----
-
-## 13. Example Outputs
-
-Input:
-
-    type = feat
-    title = My very interesting task
-    id = STK-123
-
-Pattern:
-
-    {type}/{title:slugify;max:25}-{id}
-
-Output:
-
-    feat/my-very-interesting-task-STK-123
+# new-branch
 
----
+<p align="center">
+  <img src="./logo.svg" width="180" alt="new-branch logo" />
+</p>
 
-## 14. Future Extensions
+A composable CLI to generate and optionally create standardized Git branch names using a pattern + transform pipeline.
 
-- Custom transform plugins
-- Jira integration (auto-fetch title from ID)
-- Branch existence check
-- Automatic incremental suffixing
-- Conventional commits integration
+![demo](./demo.gif)
 
 ---
 
-## 15. Summary
-
-`new-branch` is a composable, functional, extensible CLI tool for
-standardized Git branch naming.
-
-Core principles:
-
-- Functional pipeline transforms
-- Deterministic output
-- Git-safe sanitization
-- Clear precedence rules
-- Interactive fallback
-
-# new-branch
+## Why
 
-A small CLI tool to generate and optionally create standardized Git branch names
-based on a composable pattern language.
+Keep branch names consistent across your team using a declarative pattern language.
 
 ---
 
-## Installation
+## Install
 
-Using npx:
+Run without installing:
 
 ```bash
 npx new-branch
@@ -309,78 +34,32 @@ npm install -g new-branch
 
 ## Usage
 
-### Generate a branch name
+Generate a branch name:
 
 ```bash
 new-branch \
-  --pattern "{type}/{title:slugify}-{id}" \
+  --pattern "{type}/{title:slugify;max:25}-{id}" \
   --type feat \
   --title "My task" \
   --id STK-123
 ```
 
-Output:
-
-```
-feat/minha-tarefa-STK-123
-```
-
----
-
-### Create the branch automatically
+Create the branch automatically:
 
 ```bash
 new-branch \
-  --pattern "{type:upper}/{title:slugify}-{id}" \
+  --pattern "{type}/{title:slugify}-{id}" \
   --type feat \
   --title "My task" \
   --id STK-123 \
   --create
 ```
 
-This runs:
-
-```
-git switch -c <generated-branch>
-```
-
----
-
-### Interactive mode
-
-If required variables in the pattern are missing, the CLI will prompt for them.
-
-Example:
-
-```bash
-new-branch \
-  --pattern "{type:upper}/{title:slugify}-{id}" \
-  --title "My task" \
-  --id STK-123 \
-  --create
-```
-
-You will be prompted for `type`.
-
----
-
-## CLI Options
-
-| Option                    | Description                                  |
-| ------------------------- | -------------------------------------------- |
-| `-p, --pattern <pattern>` | Branch name pattern                          |
-| `--id <id>`               | Task ID                                      |
-| `--title <title>`         | Task title                                   |
-| `--type <type>`           | Branch type                                  |
-| `--create`                | Create the branch using `git switch -c`      |
-| `--no-prompt`             | Fail instead of prompting for missing values |
-| `--quiet`                 | Do not print any output                      |
-
 ---
 
 ## Pattern Language
 
-Branch names are generated from a pattern string.
+Patterns are composed of variables and ordered transforms.
 
 Example:
 
@@ -395,15 +74,14 @@ Example:
 ```
 
 - Variables are wrapped in `{}`
-- Transforms are separated by `;`
-- Transform arguments are separated by `:`
+- Transforms run left-to-right
+- Multiple transforms are separated by `;`
+- Transform arguments use `:`
 
 ---
 
 ## Built-in Variables
 
-These variables are currently supported:
-
 - `type`
 - `title`
 - `id`
@@ -412,73 +90,86 @@ These variables are currently supported:
 
 ## Built-in Transforms
 
-All transforms are pure functions and executed left-to-right.
+| Transform | Description                |
+| --------- | -------------------------- |
+| `slugify` | Convert to URL-safe slug   |
+| `lower`   | Convert to lowercase       |
+| `upper`   | Convert to uppercase       |
+| `camel`   | Convert to camelCase       |
+| `kebab`   | Convert to kebab-case      |
+| `snake`   | Convert to snake_case      |
+| `title`   | Convert to Title Case      |
+| `words:n` | Keep at most `n` words     |
+| `max:n`   | Truncate to `n` characters |
 
-### String transforms
+All transforms are pure functions and composable.
 
-| Transform | Description                 |
-| --------- | --------------------------- |
-| `lower`   | Lowercases the value        |
-| `upper`   | Uppercases the value        |
-| `slugify` | Converts to a git-safe slug |
+---
 
-### Argument-based transforms
+## Interactive Mode
 
-| Transform | Description                    | Example  |
-| --------- | ------------------------------ | -------- |
-| `max`     | Truncates string to max length | `max:25` |
+If variables referenced by the pattern are missing, the CLI prompts for them by default.
 
-Example:
+Disable prompts with:
 
-```
-{title:slugify;max:25}
+```bash
+--no-prompt
 ```
 
 ---
 
-## Git Ref Validation
-
-After rendering, branch names are:
-
-1. Lightly sanitized
-2. Validated using `git check-ref-format --branch`
+## CLI Options
 
-If invalid, the command fails.
+| Option                    | Description                         |
+| ------------------------- | ----------------------------------- |
+| `-p, --pattern <pattern>` | Branch pattern                      |
+| `--type <type>`           | Branch type                         |
+| `--title <title>`         | Task title                          |
+| `--id <id>`               | Task identifier                     |
+| `--create`                | Create branch using `git switch -c` |
+| `--no-prompt`             | Fail instead of prompting           |
+| `--quiet`                 | Suppress output                     |
 
 ---
 
-## Example
+## Project Configuration
 
-Input:
+You can define a default pattern in `package.json`:
 
-```
-type = feat
-title = My task
-id = STK-123
+```json
+{
+  "new-branch": {
+    "pattern": "{type}/{title:slugify}-{id}"
+  }
+}
 ```
 
-Pattern:
+Resolution order:
 
-```
-{type}/{title:slugify;max:25}-{id}
-```
+1. CLI flags
+2. `package.json` configuration
+3. Interactive prompt (if enabled)
 
-Output:
+---
 
-```
-feat/my-task-STK-123
-```
+## Git Safety
 
----
+After rendering, branch names are:
 
-## Roadmap
+1. Lightly sanitized
+2. Validated via `git check-ref-format --branch`
+
+Invalid names cause the command to fail.
+
+---
 
-Planned future features:
+## Development
 
-- Config file support
-- Custom transform plugins
-- Additional variable providers (e.g. git username, date)
-- Branch existence checks
+```bash
+pnpm install
+pnpm test:run
+pnpm build
+```
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "new-branch",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Generate and create standardized git branch names from a pattern.",
   "keywords": [
     "git",

package/dist/config/loadProjectConfig.test.js

@@ -1,34 +0,0 @@
-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/git/sanitizeGitRef.test.js

@@ -1,30 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { sanitizeGitRef } from "./sanitizeGitRef.js";
-describe("sanitizeGitRef", () => {
-    it("trims input and replaces whitespace with dashes", () => {
-        expect(sanitizeGitRef("  feature  new   ")).toBe("feature-new");
-    });
-    it("removes forbidden characters and sequences", () => {
-        const input = "~^:??*[\\]name@{weird}";
-        // forbidden chars removed and @{ removed
-        expect(sanitizeGitRef(input)).toBe("nameweird}");
-    });
-    it("collapses multiple slashes and removes leading/trailing slashes", () => {
-        expect(sanitizeGitRef("///a//b/c///")).toBe("a/b/c");
-    });
-    it("collapses repeated dots and trims trailing dots", () => {
-        expect(sanitizeGitRef("v1..0...")).toBe("v1.0");
-    });
-    it("prevents leading dash or slash and trailing dot or slash", () => {
-        expect(sanitizeGitRef("-/--abc/.")).toBe("abc");
-    });
-    it("removes trailing .lock suffix", () => {
-        expect(sanitizeGitRef("release.lock")).toBe("release");
-        // multiple .lock occurrences only remove final suffix
-        expect(sanitizeGitRef("a.lock.lock")).toBe("a.lock");
-    });
-    it("works with an empty-ish result (keeps dot/punctuations according to sanitizer)", () => {
-        // Implementation collapses dots and slashes but does not remove the leading dot
-        expect(sanitizeGitRef("   ....///--- ")).toBe("./---");
-    });
-});

package/dist/parseArgs.test.js

@@ -1,50 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parseArgs } from "./parseArgs.js";
-describe("parseArgs", () => {
-    it("parses long options", () => {
-        const argv = [
-            "node",
-            "cli",
-            "--pattern",
-            "{type}/{title}-{id}",
-            "--id",
-            "STK-123",
-            "--title",
-            "Minha tarefa",
-            "--type",
-            "feat",
-            "--create",
-        ];
-        const res = parseArgs(argv);
-        expect(res.options.pattern).toBe("{type}/{title}-{id}");
-        expect(res.options.id).toBe("STK-123");
-        expect(res.options.title).toBe("Minha tarefa");
-        expect(res.options.type).toBe("feat");
-        expect(res.options.create).toBe(true);
-        expect(res.args).toEqual([]);
-    });
-    it("parses short -p as pattern", () => {
-        const argv = ["node", "cli", "-p", "{type}/{title}-{id}"];
-        const res = parseArgs(argv);
-        expect(res.options.pattern).toBe("{type}/{title}-{id}");
-    });
-    it("strips tsx double-dash separator", () => {
-        const argv = [
-            "node",
-            "cli",
-            "--",
-            "--pattern",
-            "{type}/{title}-{id}",
-            "--id",
-            "STK-123",
-        ];
-        const res = parseArgs(argv);
-        expect(res.options.pattern).toBe("{type}/{title}-{id}");
-        expect(res.options.id).toBe("STK-123");
-    });
-    it("supports --no-prompt", () => {
-        const argv = ["node", "cli", "--no-prompt"];
-        const res = parseArgs(argv);
-        expect(res.options.prompt).toBe(false);
-    });
-});

package/dist/pattern/parsePattern.test.js

@@ -1,25 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parsePattern } from "./parsePattern.js";
-describe("parsePattern", () => {
-    it("parses literals + variables + transforms", () => {
-        const res = parsePattern("{type}/{title:slugify;max:25}-{id}");
-        expect(res.variablesUsed).toEqual(["type", "title", "id"]);
-        expect(res.nodes).toEqual([
-            { kind: "variable", name: "type", transforms: [] },
-            { kind: "literal", value: "/" },
-            {
-                kind: "variable",
-                name: "title",
-                transforms: [
-                    { name: "slugify", args: [] },
-                    { name: "max", args: ["25"] },
-                ],
-            },
-            { kind: "literal", value: "-" },
-            { kind: "variable", name: "id", transforms: [] },
-        ]);
-    });
-    it("throws on missing closing brace", () => {
-        expect(() => parsePattern("{type/{id}")).toThrow(/missing "}"|Invalid pattern/);
-    });
-});

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

@@ -1,13 +0,0 @@
-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.test.js

@@ -1,35 +0,0 @@
-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.test.js

@@ -1,13 +0,0 @@
-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/lower.test.js

@@ -1,10 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { lower } from "./lower.js";
-describe("lower transform", () => {
-    it("converts to lowercase", () => {
-        expect(lower.fn("Hello WORLD", [])).toBe("hello world");
-    });
-    it("keeps non-letter characters", () => {
-        expect(lower.fn("123-ÁÉ!", [])).toBe("123-áé!");
-    });
-});

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

@@ -1,13 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { max } from "./max.js";
-describe("max transform", () => {
-    it("truncates the value to the given length", () => {
-        expect(max.fn("abcdef", ["3"])).toBe("abc");
-        expect(max.fn("short", ["10"])).toBe("short");
-    });
-    it("throws on negative or non-finite sizes", () => {
-        expect(() => max.fn("abc", ["-1"])).toThrow();
-        expect(() => max.fn("abc", ["not-a-number"])).toThrow();
-        expect(() => max.fn("abc", [])).toThrow();
-    });
-});

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

@@ -1,46 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { renderPattern } from "./renderPattern.js";
-import { parsePattern } from "../parsePattern.js";
-import { lower } from "./lower.js";
-import { upper } from "./upper.js";
-import { max } from "./max.js";
-import { slugify } from "./slugify.js";
-const defaultTransforms = {
-    [lower.name]: lower.fn,
-    [upper.name]: upper.fn,
-    [max.name]: max.fn,
-    [slugify.name]: slugify.fn,
-};
-describe("renderPattern", () => {
-    it("renders literals and variables without transforms", () => {
-        const parsed = parsePattern("{type}/{title}-{id}");
-        const out = renderPattern(parsed, { type: "feat", title: "My Task", id: "123" }, { transforms: defaultTransforms });
-        expect(out).toBe("feat/My Task-123");
-    });
-    it("applies transforms in order (slugify then max)", () => {
-        const parsed = parsePattern("{title:slugify;max:5}");
-        const out = renderPattern(parsed, { title: "Título grande" }, { transforms: defaultTransforms });
-        // slugify -> "titulo-grande" then max:5 -> "titul"
-        expect(out).toBe("titul");
-    });
-    it("throws when an unknown transform is used", () => {
-        const parsed = {
-            nodes: [{ kind: "variable", name: "foo", transforms: [{ name: "nope", args: [] }] }],
-            variablesUsed: ["foo"],
-        };
-        expect(() => renderPattern(parsed, { foo: "bar" }, { transforms: defaultTransforms })).toThrow(/Unknown transform/i);
-    });
-    it("throws on missing variable in strict mode (default)", () => {
-        const parsed = parsePattern("{id}");
-        expect(() => renderPattern(parsed, {}, { transforms: defaultTransforms })).toThrow(/Missing value/);
-    });
-    it("returns empty for missing variable when strict is false", () => {
-        const parsed = parsePattern("pre-{id}-post");
-        const out = renderPattern(parsed, {}, { transforms: defaultTransforms, strict: false });
-        expect(out).toBe("pre--post");
-    });
-    it("propagates transform errors (invalid max arg)", () => {
-        const parsed = parsePattern("{title:max:-1}");
-        expect(() => renderPattern(parsed, { title: "abc" }, { transforms: defaultTransforms })).toThrow();
-    });
-});

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

@@ -1,14 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { slugify } from "./slugify.js";
-describe("slugify transform", () => {
-    it("removes accents, lowercases and replaces non-alphanum with dashes", () => {
-        const input = "Título com Acentos & símbolos!";
-        const out = slugify.fn(input, []);
-        expect(out).toBe("titulo-com-acentos-simbolos");
-    });
-    it("collapses multiple separators into one and trims dashes", () => {
-        const input = "  --Hello___World--  ";
-        const out = slugify.fn(input, []);
-        expect(out).toBe("hello-world");
-    });
-});

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

@@ -1,13 +0,0 @@
-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.test.js

@@ -1,13 +0,0 @@
-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/upper.test.js

@@ -1,10 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { upper } from "./upper.js";
-describe("upper transform", () => {
-    it("converts to uppercase", () => {
-        expect(upper.fn("Hello world", [])).toBe("HELLO WORLD");
-    });
-    it("keeps non-letter characters", () => {
-        expect(upper.fn("123-áé!", [])).toBe("123-ÁÉ!");
-    });
-});

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

@@ -1,16 +0,0 @@
-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/resolveMissingValues.test.js

@@ -1,64 +0,0 @@
-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");
-    });
-});