new-branch 0.2.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/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/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/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/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/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/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/runtime/resolveMissingValues.js

@@ -1,11 +1,34 @@
 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 "type" variable is resolved using a select menu with predefined choices.
+ * 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "new-branch",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Generate and create standardized git branch names from a pattern.",
   "keywords": [
     "git",
@@ -20,6 +20,7 @@
     "prepack": "pnpm build && pnpm test: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"
@@ -41,13 +42,14 @@
     "url": "https://github.com/teles/new-branch/issues"
   },
   "new-branch": {
-    "pattern": "{type}/{title}-{id}"
+    "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",

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/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/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-ÁÉ!");
-    });
-});