new-branch 0.3.0 → 0.4.0

package/README.md

@@ -1,299 +1,30 @@
-# 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}
+# new-branch
 
-Output:
+<p align="center">
+  <img src="./logo.svg" width="180" alt="new-branch logo" />
+</p>
 
-    feat/my-very-interesting-task-STK-123
+> “Explicit is better than implicit.”
+> — The Zen of Python (PEP 20)
 
----
+A composable CLI to generate and optionally create standardized Git branch names using a pattern + transform pipeline.
 
-## 14. Future Extensions
+![demo](./demo.gif)
 
-- Custom transform plugins
-- Jira integration (auto-fetch title from ID)
-- Branch existence check
-- Automatic incremental suffixing
-- Conventional commits integration
+[![CI](https://github.com/teles/new-branch/actions/workflows/ci.yml/badge.svg)](https://github.com/teles/new-branch/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/teles/new-branch/branch/main/graph/badge.svg)](https://codecov.io/gh/teles/new-branch)
 
 ---
 
-## 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 +40,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,90 +80,137 @@ 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:
+### Core Variables
 
 - `type`
 - `title`
 - `id`
 
+### Date Built-ins (derived from local system time)
+
+- `year` → YYYY
+- `month` → MM (zero padded)
+- `day` → DD (zero padded)
+- `date` → YYYY-MM-DD
+- `dateCompact` → YYYYMMDD
+
 ---
 
 ## 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:
+### Git Configuration
 
-```
-{type}/{title:slugify;max:25}-{id}
+You can also define a default pattern using Git config:
+
+```bash
+git config --local new-branch.pattern "{type}/{title:slugify}-{id}"
 ```
 
-Output:
+Or globally:
 
+```bash
+git config --global new-branch.pattern "{type}/{title:slugify}-{id}"
 ```
-feat/my-task-STK-123
+
+To remove the pattern from Git config:
+
+```bash
+# Remove from local repository
+git config --unset --local new-branch.pattern
+
+# Remove from global config
+git config --unset --global new-branch.pattern
 ```
 
+When using Git config, the resolution order becomes:
+
+1. CLI flags
+2. `package.json` configuration
+3. Git config (`new-branch.pattern`)
+4. Interactive prompt (if enabled)
+
 ---
 
-## Roadmap
+## Git Safety
+
+After rendering, branch names are:
+
+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/cli.js

@@ -4,7 +4,9 @@ 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 { getBuiltinValues } from "./runtime/builtins.js";
 import { loadProjectConfig } from "./config/loadProjectConfig.js";
+import { getGitConfig } from "./git/gitConfig.js";
 import { sanitizeGitRef } from "./git/sanitizeGitRef.js";
 import { validateBranchName } from "./git/validateBranchName.js";
 import { createBranch } from "./git/createBranch.js";
@@ -46,7 +48,7 @@ function toInitialValues(args) {
         type: args.options.type,
     };
 }
-async function run() {
+export 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
@@ -62,14 +64,23 @@ async function run() {
     const prompt = args.options.prompt !== false;
     // Pipeline: pattern -> AST -> resolve values -> render -> sanitize -> validate -> (optional) git -> output
     const projectConfig = await loadProjectConfig();
-    const resolvedPattern = args.options.pattern ?? projectConfig.pattern;
+    // Git config (respects local -> global precedence automatically)
+    let gitPattern;
+    if (!args.options.pattern && !projectConfig.pattern) {
+        gitPattern = await getGitConfig("new-branch.pattern");
+    }
+    const resolvedPattern = args.options.pattern ?? projectConfig.pattern ?? gitPattern;
     const patternRes = requirePattern(resolvedPattern);
     if (!isOk(patternRes))
         fail("Invalid CLI arguments.", patternRes.error);
     const astRes = safe(() => parsePattern(patternRes.value));
     if (!isOk(astRes))
         fail("Invalid pattern.", astRes.error);
-    const initialValues = toInitialValues(args);
+    const builtinValues = getBuiltinValues();
+    const initialValues = {
+        ...builtinValues,
+        ...toInitialValues(args),
+    };
     const valuesRes = await safeAsync(() => resolveMissingValues(astRes.value, initialValues, {
         prompt,
     }));
@@ -106,4 +117,8 @@ async function run() {
         }
     }
 }
-run().catch((e) => fail("Unexpected error in CLI.", e));
+// Only execute the CLI automatically when not running tests.
+// In tests, `run` can be imported and called directly.
+if (process.env.NODE_ENV !== "test") {
+    run().catch((e) => fail("Unexpected error in CLI.", e));
+}

package/dist/git/gitConfig.js

@@ -0,0 +1,11 @@
+import { execa } from "execa";
+export async function getGitConfig(key) {
+    try {
+        const { stdout } = await execa("git", ["config", "--get", key]);
+        const value = stdout.trim();
+        return value.length ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/pattern/transforms/index.js

@@ -1,16 +1,22 @@
+import { buildRegistry } from "../../pattern/transforms/registry.js";
 import { lower } from "../../pattern/transforms/lower.js";
 import { upper } from "../../pattern/transforms/upper.js";
 import { max } from "../../pattern/transforms/max.js";
-// import { replace } from "./replace.js";
-import { slugify } from "./slugify.js";
-export const allTransforms = [lower, upper, max, slugify];
-export function buildRegistry(defs) {
-    const registry = {};
-    for (const d of defs) {
-        if (registry[d.name])
-            throw new Error(`Duplicate transform name: "${d.name}"`);
-        registry[d.name] = d.fn;
-    }
-    return registry;
-}
+import { slugify } from "../../pattern/transforms/slugify.js";
+import { camel } from "../../pattern/transforms/camel.js";
+import { kebab } from "../../pattern/transforms/kebab.js";
+import { snake } from "../../pattern/transforms/snake.js";
+import { title } from "../../pattern/transforms/title.js";
+import { words } from "../../pattern/transforms/words.js";
+export const allTransforms = [
+    lower,
+    upper,
+    max,
+    slugify,
+    camel,
+    kebab,
+    snake,
+    title,
+    words,
+];
 export const defaultTransforms = buildRegistry(allTransforms);

package/dist/pattern/transforms/registry.js

@@ -0,0 +1,10 @@
+export function buildRegistry(defs) {
+    const registry = {};
+    for (const d of defs) {
+        if (registry[d.name]) {
+            throw new Error(`Duplicate transform name: "${d.name}"`);
+        }
+        registry[d.name] = d.fn;
+    }
+    return registry;
+}

package/dist/runtime/builtins.js

@@ -0,0 +1,44 @@
+/**
+ * Pads a number with a leading zero when necessary.
+ *
+ * @param n - Number to pad.
+ * @returns A zero-padded string (e.g., 2 → "02").
+ */
+function pad(n) {
+    return String(n).padStart(2, "0");
+}
+/**
+ * Returns built-in date-based variables derived from
+ * the local system time.
+ *
+ * This function is intentionally synchronous and pure.
+ * The optional `now` parameter allows deterministic testing.
+ *
+ * Provided variables:
+ *
+ * - `year`        → YYYY
+ * - `month`       → MM (zero padded)
+ * - `day`         → DD (zero padded)
+ * - `date`        → YYYY-MM-DD
+ * - `dateCompact` → YYYYMMDD
+ *
+ * @param now - Optional Date instance used to generate values.
+ *              Defaults to the current system date/time.
+ * @returns An object containing built-in date variables.
+ *
+ * @example
+ * const builtins = getBuiltinValues(new Date("2026-02-19"));
+ * builtins.date; // "2026-02-19"
+ */
+export function getBuiltinValues(now = new Date()) {
+    const year = String(now.getFullYear());
+    const month = pad(now.getMonth() + 1);
+    const day = pad(now.getDate());
+    return {
+        year,
+        month,
+        day,
+        date: `${year}-${month}-${day}`,
+        dateCompact: `${year}${month}${day}`,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "new-branch",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Generate and create standardized git branch names from a pattern.",
   "keywords": [
     "git",
@@ -48,10 +48,17 @@
   "packageManager": "pnpm@10.22.0",
   "devDependencies": {
     "@eslint/js": "10.0.1",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.6",
+    "@semantic-release/npm": "^13.1.4",
+    "@semantic-release/release-notes-generator": "^14.1.0",
     "@types/node": "25.2.3",
     "@vitest/coverage-v8": "4.0.18",
     "eslint": "10.0.0",
     "prettier": "3.8.1",
+    "semantic-release": "^25.0.3",
     "tsc-alias": "1.8.16",
     "tsx": "4.21.0",
     "typescript": "5.9.3",

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");
-    });
-});