@tertium/hlpr 0.5.8 → 0.6.0

package/README.md

@@ -45,126 +45,23 @@ hlpr -f ssh init dir
 
 ## Available Commands
 
-### TypeScript Commands
-
-#### file rename
-
-Recursively rename files and folders according to a specific case style.
-
-**Supported styles:**
-- `title_underscore` - Title_Case_With_Underscores
-- `snake` - snake_case_lowercase
-- `kebab` - kebab-case-lowercase
-- `camel` - camelCaseLowerFirst
-- `pascal` - PascalCaseUpperFirst
-- `upper` - UPPER_CASE_WITH_UNDERSCORES
-- `lower` - lower_case_with_underscores
-
-**Usage:**
-```bash
-# Dry run (preview changes without applying)
-hlpr file rename ./my-project kebab --dry
-hlpr file rename ./src snake -n
-
-# Apply changes
-hlpr file rename ./my-project kebab
-hlpr file rename ./docs pascal
-```
-
-**Features:**
-- ✅ Recursive directory traversal
-- ✅ Extension preservation
-- ✅ Leading dot file support (e.g., `.gitignore`)
-- ✅ Case-only rename handling (Windows compatibility)
-- ✅ Conflict resolution (adds `_N` suffix)
-- ✅ Dry-run mode (`--dry` or `-n`)
-
-**See:** [`src/commands/file/rename/README.md`](src/commands/file/rename/README.md) for full documentation.
-
----
-
-#### help
+See individual command documentation for detailed usage, options, and examples.
 
-Display help information about hlpr commands.
-
-**Usage:**
-```bash
-hlpr help
-```
+### TypeScript Commands
 
----
+- **[file rename](src/commands/file/rename/README.md)** - Recursively rename files/folders with various case styles
+- **[help](src/commands/help/README.md)** - Display help information about hlpr commands
+- **[process list-port](src/commands/process/list-port/README.md)** - List processes running on a port
+- **[process kill-port](src/commands/process/kill-port/README.md)** - Kill processes on a port
 
 ### Shell Script Commands
 
 Shell scripts support variable substitution using `{{variable}}` syntax.
 
-#### git
-
-Helpful git utilities for common development workflows.
-
-**Usage:**
-```bash
-hlpr git <command>
-```
-
-**Commands:**
-- `fodd` - Fetch and update develop branch from origin
-- `precommit` - Run build and stage binaries before commit
-- `switch-clean` - Safely switch to a branch and delete the previous one (local & remote)
-
-**See:** [`src/commands/git/README.md`](src/commands/git/README.md) for full documentation.
-
----
-
-#### hello
-
-Example/demo commands for testing the hlpr CLI tool.
-
-**Usage:**
-```bash
-hlpr hello world
-```
-
-Prompts for input and prints a personalized greeting with variable substitution.
-
-**See:** [`src/commands/hello/README.md`](src/commands/hello/README.md) for full documentation.
-
----
-
-#### nvm
-
-Node Version Manager utilities for managing Node.js versions.
-
-**Usage:**
-```bash
-hlpr nvm <command>
-```
-
-**Commands:**
-- `install` - Install Node Version Manager (nvm)
-- `lts` - Install and use Node.js LTS version
-
-**See:** [`src/commands/nvm/README.md`](src/commands/nvm/README.md) for full documentation.
-
----
-
-#### ssh
-
-SSH configuration and setup utilities.
-
-**Usage:**
-```bash
-hlpr ssh init-dir
-```
-
-Initializes SSH directory with proper permissions:
-- `~/.ssh/` directory with 700 permissions
-- `~/.ssh/known_hosts` with 644 permissions
-- `~/.ssh/config` with 644 permissions
-
-Portable across Unix/Linux/macOS and Git Bash on Windows.
-
-**See:** [`src/commands/ssh/README.md`](src/commands/ssh/README.md) for full documentation.
+- **[git](src/commands/git/README.md)** - Git utilities (fodd, precommit, switch-clean)
+- **[hello](src/commands/hello/README.md)** - Example greeting command with variable substitution
+- **[nvm](src/commands/nvm/README.md)** - Node Version Manager utilities
+- **[ssh](src/commands/ssh/README.md)** - SSH configuration and setup utilities
 
 ## How It Works
 
@@ -183,21 +80,40 @@ Portable across Unix/Linux/macOS and Git Bash on Windows.
 ## Directory Structure
 
 ```
-commands/
-├── file/
-│   └── rename/
-│       ├── rename.ts
-│       ├── rename.test.ts
+src/
+├── core/
+│   └── command/
+│       └── command.types.ts
+├── commands/
+│   ├── file/
+│   │   └── rename/
+│   │       ├── rename.ts
+│   │       ├── rename.test.ts
+│   │       └── README.md
+│   ├── git/
+│   │   ├── fodd.sh
+│   │   ├── precommit.sh
+│   │   ├── switch-clean.sh
+│   │   └── README.md
+│   ├── hello/
+│   │   ├── world.sh
+│   │   └── README.md
+│   ├── nvm/
+│   │   ├── install.sh
+│   │   ├── lts.sh
+│   │   └── README.md
+│   ├── process/
+│   │   ├── kill-port/
+│   │   │   ├── kill-port.ts
+│   │   │   └── README.md
+│   │   └── list-port/
+│   │       ├── list-port.ts
+│   │       └── README.md
+│   └── ssh/
+│       ├── init-dir.sh
 │       └── README.md
-├── git/
-│   └── fodd.sh
-├── hello/
-│   └── world.sh
-├── nvm/
-│   ├── install.sh
-│   └── lts.sh
-└── ssh/
-    └── initdir.sh
+├── index.ts
+└── commands.ts
 ```
 
 ## Adding Your Own Scripts
@@ -246,6 +162,113 @@ The utility maps command arguments to script files:
 
 - `hlpr file rename <args>` → runs `commands/file/rename/rename.ts`
 
+## How Shell Scripts (.sh) Work
+
+Shell scripts are bash scripts stored in `src/commands/<category>/` directories. They support interactive variable substitution and are cross-platform compatible.
+
+### Variable Substitution
+
+Shell scripts can use `{{variable}}` placeholders for user input:
+
+```bash
+#!/bin/bash
+# Example: src/commands/greet/hello.sh
+echo "Hello {{name}}, welcome to {{place}}"
+```
+
+When you run `hlpr greet hello`, the utility:
+1. Reads the script
+2. Finds all `{{variable}}` placeholders
+3. Prompts you to enter values for each variable
+4. Executes the script with variables replaced
+
+**Example interaction:**
+```
+$ hlpr greet hello
+Enter value for name: Alice
+Enter value for place: Wonderland
+Hello Alice, welcome to Wonderland
+```
+
+### Script Execution
+
+- Each line of the script is executed sequentially
+- If any line fails and `-f` flag is not set, execution stops
+- Scripts have access to standard bash features (pipes, redirects, etc.)
+
+### Windows Compatibility
+
+`.sh` scripts run on Windows through **PowerShell** and the modern cross-platform command stack.
+
+**How it works:**
+
+1. User runs: `hlpr git fodd`
+2. hlpr detects the platform is Windows
+3. hlpr invokes **PowerShell** to execute the `.sh` script
+4. PowerShell (v7+) and installed tools provide Unix-like command support
+5. Commands like `grep`, `sed`, `ls`, etc. work through various implementations
+
+**Why this works:**
+
+Modern Windows systems have multiple sources for Unix-like commands:
+
+- **PowerShell 7+** - Cross-platform, provides built-in Unix-like commands and aliases (ls, grep, select-string, etc.)
+- **Git** - Installs Unix utilities as part of its toolchain
+- **Node.js** - Provides command-line tools that work cross-platform
+- **Package managers** - scoop, chocolatey, and winget provide Unix tools
+- **WSL 2** - Windows Subsystem for Linux provides full Linux compatibility
+
+Scripts work because:
+- Modern tools use consistent command-line interfaces across platforms
+- PowerShell Core has native cross-platform support
+- Common utilities are available through multiple sources in system PATH
+
+**Example:**
+
+```bash
+#!/bin/bash
+# This script works on Windows, Linux, and macOS
+echo "Running on: $(uname -s || echo 'Windows PowerShell')"
+if [ -d "./src" ]; then
+  echo "Found src directory"
+  ls src | head -5
+fi
+```
+
+**Requirements:**
+
+- **Modern PowerShell** (v7+) is recommended for full compatibility
+- **Windows 10+** with default PowerShell Core support
+- **Git** installed (provides additional Unix utilities)
+- **Node.js** for runtime support
+
+No special configuration needed - hlpr automatically detects and uses PowerShell on Windows.
+
+### Creating Shell Scripts
+
+1. Create directory: `src/commands/<category>/`
+2. Add `.sh` file: `<command>.sh`
+3. Add shebang: `#!/bin/bash`
+4. Use `{{variable}}` for user input
+5. Build with `bun run build` (copies `.sh` files to `bin/commands/`)
+
+Example:
+
+```bash
+#!/bin/bash
+# src/commands/greet/hello.sh
+NAME={{name}}
+echo "Hello $NAME!"
+echo "Today is $(date '+%A')"
+```
+
+### Building and Distribution
+
+Shell scripts are:
+- **Copied** (not compiled) during build to `bin/commands/`
+- **Distributed** as part of the published package
+- **Platform-compatible** across Linux, macOS, and Windows (with Git Bash)
+
 ## Error Handling
 
 By default, the utility stops execution if any command fails. Use the `-f` flag to continue execution despite failures:
@@ -263,10 +286,14 @@ hlpr -f ssh init dir
 ```bash
 # Clone the repository
 git clone https://github.com/tertiumnon/hlpr.git
+cd hlpr
 
 # Install dependencies
 npm install
 
+# Setup git hooks (runs tests before commit)
+npm run setup:hooks
+
 # Build the project
 bun run build
 
@@ -274,6 +301,20 @@ bun run build
 npm link
 ```
 
+### Git Hooks
+
+This project uses native git hooks (`.githooks/pre-commit`) to run tests before each commit. After cloning or pulling, ensure hooks are configured:
+
+```bash
+npm run setup:hooks
+```
+
+The pre-commit hook:
+- Runs unit and integration tests
+- Runs end-to-end tests
+- Aborts commit if tests fail
+- Can be skipped with `SKIP_E2E=1 git commit` (not recommended)
+
 ## License
 
 MIT

package/bin/commands/file/rename/rename.js

@@ -1,3 +1,4 @@
+// @bun
 // src/commands/file/rename/rename.ts
 import fs from "fs/promises";
 import path from "path";
@@ -21,7 +22,7 @@ function transformBasename(basename, style) {
     return basename;
   switch (style) {
     case "title_underscore":
-      return leadingDot + words.map(cap).join("_") + ext;
+      return leadingDot + titleCase(words).join("_") + ext;
     case "snake":
       return leadingDot + words.map((w) => w.toLowerCase()).join("_") + ext;
     case "kebab":
@@ -31,7 +32,7 @@ function transformBasename(basename, style) {
     case "pascal":
       return leadingDot + words.map(cap).join("") + ext;
     case "pascal_underscore":
-      return leadingDot + words.map(cap).join("_") + ext;
+      return leadingDot + titleCase(words).join("_") + ext;
     case "upper":
       return leadingDot + words.join("_").toUpperCase() + ext;
     case "lower":
@@ -40,11 +41,48 @@ function transformBasename(basename, style) {
       return leadingDot + core + ext;
   }
 }
+function isAllCaps(s) {
+  return s.length > 0 && s === s.toUpperCase() && s !== s.toLowerCase();
+}
 function cap(s) {
   if (!s)
     return s;
   return s[0].toUpperCase() + s.slice(1).toLowerCase();
 }
+function titleCase(words) {
+  const smallWords = new Set([
+    "a",
+    "an",
+    "and",
+    "as",
+    "at",
+    "but",
+    "by",
+    "for",
+    "from",
+    "in",
+    "into",
+    "nor",
+    "of",
+    "on",
+    "or",
+    "the",
+    "to",
+    "with"
+  ]);
+  return words.map((word, index) => {
+    if (isAllCaps(word)) {
+      return word;
+    }
+    if (index === 0) {
+      return cap(word);
+    }
+    if (smallWords.has(word.toLowerCase())) {
+      return word.toLowerCase();
+    }
+    return cap(word);
+  });
+}
 async function exists(p) {
   try {
     await fs.access(p);
@@ -229,7 +267,7 @@ if (import.meta.url.endsWith(process.argv[1]?.replace(/\\/g, "/"))) {
       console.log(`Renamed ${performed.length} items:`);
     }
     performed.forEach(({ from, to }) => {
-      console.log(`  ${from} → ${to}`);
+      console.log(`  ${from} \u2192 ${to}`);
     });
   }).catch((err) => {
     console.error("Error:", err);

package/bin/commands/process/kill-port/kill-port.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/commands/process/kill-port/kill-port.ts
+import { execSync, spawnSync } from "child_process";
+import { platform } from "os";
+function getProcessOnWindowsPort(port) {
+  try {
+    const output = execSync(`netstat -ano | findstr :${port}`, { encoding: "utf-8" });
+    const pids = [];
+    const lines = output.split(`
+`);
+    for (const line of lines) {
+      const match = line.match(/\s+(\d+)\s*$/);
+      if (match) {
+        const pid = parseInt(match[1], 10);
+        if (pid > 0 && !pids.includes(pid)) {
+          pids.push(pid);
+        }
+      }
+    }
+    return pids;
+  } catch (error) {
+    return [];
+  }
+}
+function getProcessOnLinuxPort(port) {
+  try {
+    const output = execSync(`lsof -i :${port} -n -P`, { encoding: "utf-8" });
+    const pids = [];
+    const lines = output.split(`
+`);
+    for (let i = 1;i < lines.length; i++) {
+      const parts = lines[i].trim().split(/\s+/);
+      if (parts.length > 1) {
+        const pid = parseInt(parts[1], 10);
+        if (!isNaN(pid) && !pids.includes(pid)) {
+          pids.push(pid);
+        }
+      }
+    }
+    return pids;
+  } catch {
+    try {
+      const output = execSync(`netstat -tulnp 2>/dev/null | grep :${port}`, { encoding: "utf-8" });
+      const pids = [];
+      const lines = output.split(`
+`);
+      for (const line of lines) {
+        const match = line.match(/(\d+)\//);
+        if (match) {
+          const pid = parseInt(match[1], 10);
+          if (!pids.includes(pid)) {
+            pids.push(pid);
+          }
+        }
+      }
+      return pids;
+    } catch {
+      return [];
+    }
+  }
+}
+function killProcessOnWindows(pid, force, verbose) {
+  try {
+    const args = force ? ["/PID", pid.toString(), "/F"] : ["/PID", pid.toString()];
+    const result = spawnSync("taskkill", args, { encoding: "utf-8" });
+    if (result.status === 0) {
+      if (verbose)
+        console.log(`\u2713 Killed process ${pid}`);
+      return true;
+    } else {
+      if (verbose)
+        console.error(`\u2717 Failed to kill process ${pid}: ${result.stderr}`);
+      return false;
+    }
+  } catch (error) {
+    if (verbose)
+      console.error(`\u2717 Error killing process ${pid}: ${error}`);
+    return false;
+  }
+}
+function killProcessOnLinux(pid, force, verbose) {
+  try {
+    const signal = force ? "SIGKILL" : "SIGTERM";
+    const result = spawnSync("kill", [`-${signal}`, pid.toString()], { encoding: "utf-8" });
+    if (result.status === 0) {
+      if (verbose)
+        console.log(`\u2713 Killed process ${pid} with ${signal}`);
+      return true;
+    } else {
+      if (verbose)
+        console.error(`\u2717 Failed to kill process ${pid}: ${result.stderr}`);
+      return false;
+    }
+  } catch (error) {
+    if (verbose)
+      console.error(`\u2717 Error killing process ${pid}: ${error}`);
+    return false;
+  }
+}
+async function killPort(port, options = {}) {
+  const { force = false, verbose = false } = options;
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`Invalid port number: ${port}. Port must be between 1 and 65535.`);
+  }
+  const os = platform();
+  let pids = [];
+  if (verbose)
+    console.log(`Searching for processes on port ${port} (${os})...`);
+  if (os === "win32") {
+    pids = getProcessOnWindowsPort(port);
+  } else {
+    pids = getProcessOnLinuxPort(port);
+  }
+  if (pids.length === 0) {
+    if (verbose)
+      console.log(`No processes found on port ${port}`);
+    return { killed: [], failed: [] };
+  }
+  if (verbose)
+    console.log(`Found ${pids.length} process(es) on port ${port}: ${pids.join(", ")}`);
+  const killed = [];
+  const failed = [];
+  for (const pid of pids) {
+    let success;
+    if (os === "win32") {
+      success = killProcessOnWindows(pid, force, verbose);
+    } else {
+      success = killProcessOnLinux(pid, force, verbose);
+    }
+    if (success) {
+      killed.push(pid);
+    } else {
+      failed.push(pid);
+    }
+  }
+  return { killed, failed };
+}
+if (import.meta.url.endsWith(process.argv[1]?.replace(/\\/g, "/"))) {
+  const args = process.argv.slice(2);
+  if (args.includes("--help") || args.includes("-h") || args.length === 0) {
+    console.log("Usage: kill-port <port> [options]");
+    console.log("Kill process(es) running on a specified port (Windows & Linux support)");
+    console.log();
+    console.log("Arguments:");
+    console.log("  port                  Port number (1-65535)");
+    console.log();
+    console.log("Options:");
+    console.log("  -f, --force           Force kill (SIGKILL on Linux, /F on Windows)");
+    console.log("  -v, --verbose         Show verbose output");
+    console.log("  -h, --help            Show this help message");
+    console.log();
+    console.log("Examples:");
+    console.log("  hlpr process kill-port 3000");
+    console.log("  hlpr process kill-port 8080 --force");
+    console.log("  hlpr process kill-port 5432 -v");
+    process.exit(0);
+  }
+  const port = parseInt(args[0], 10);
+  const force = args.includes("-f") || args.includes("--force");
+  const verbose = args.includes("-v") || args.includes("--verbose");
+  killPort(port, { force, verbose }).then((result) => {
+    if (result.killed.length > 0) {
+      console.log(`Successfully killed ${result.killed.length} process(es) on port ${port}`);
+    }
+    if (result.failed.length > 0) {
+      console.error(`Failed to kill ${result.failed.length} process(es): ${result.failed.join(", ")}`);
+      process.exit(1);
+    }
+    if (result.killed.length === 0 && result.failed.length === 0) {
+      console.log(`No processes found on port ${port}`);
+    }
+    process.exit(0);
+  }).catch((error) => {
+    console.error("Error:", error.message);
+    process.exit(1);
+  });
+}
+var kill_port_default = { killPort };
+export {
+  killPort,
+  kill_port_default as default
+};

package/bin/commands/process/list-port/list-port.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/commands/process/list-port/list-port.ts
+import { execSync } from "child_process";
+import { platform } from "os";
+function getProcessesOnWindowsPort(port) {
+  try {
+    const output = execSync(`netstat -ano | findstr :${port}`, { encoding: "utf-8" });
+    const processes = [];
+    const lines = output.split(`
+`);
+    const pids = new Set;
+    for (const line of lines) {
+      const match = line.match(/\s+(\d+)\s*$/);
+      if (match) {
+        const pid = parseInt(match[1], 10);
+        if (pid > 0 && !pids.has(pid)) {
+          pids.add(pid);
+          try {
+            const taskOutput = execSync(`tasklist /FI "PID eq ${pid}" /NH /FO CSV`, { encoding: "utf-8" }).trim();
+            const parts = taskOutput.split('","');
+            const command = parts[0].replace(/^"|"$/g, "");
+            processes.push({
+              pid,
+              state: "LISTENING",
+              command
+            });
+          } catch {
+            processes.push({
+              pid,
+              state: "LISTENING"
+            });
+          }
+        }
+      }
+    }
+    return processes;
+  } catch (error) {
+    return [];
+  }
+}
+function getProcessesOnLinuxPort(port) {
+  try {
+    const output = execSync(`lsof -i :${port} -n -P`, { encoding: "utf-8" });
+    const processes = [];
+    const lines = output.split(`
+`);
+    const pids = new Set;
+    for (let i = 1;i < lines.length; i++) {
+      const parts = lines[i].trim().split(/\s+/);
+      if (parts.length > 2) {
+        const command = parts[0];
+        const pid = parseInt(parts[1], 10);
+        const state = parts[7] || "LISTENING";
+        if (!isNaN(pid) && pid > 0 && !pids.has(pid)) {
+          pids.add(pid);
+          processes.push({
+            pid,
+            state,
+            command
+          });
+        }
+      }
+    }
+    return processes;
+  } catch {
+    try {
+      const output = execSync(`netstat -tulnp 2>/dev/null | grep :${port}`, { encoding: "utf-8" });
+      const processes = [];
+      const lines = output.split(`
+`);
+      const pids = new Set;
+      for (const line of lines) {
+        const match = line.match(/(\d+)\/(.+)/);
+        if (match) {
+          const pid = parseInt(match[1], 10);
+          const command = match[2];
+          if (!pids.has(pid)) {
+            pids.add(pid);
+            processes.push({
+              pid,
+              state: "LISTENING",
+              command
+            });
+          }
+        }
+      }
+      return processes;
+    } catch {
+      return [];
+    }
+  }
+}
+function formatTable(processes) {
+  if (processes.length === 0) {
+    return "No processes found";
+  }
+  const pidWidth = 10;
+  const stateWidth = 12;
+  const commandWidth = 50;
+  const header = `${"PID".padEnd(pidWidth)} ${"STATE".padEnd(stateWidth)} COMMAND`;
+  const separator = "\u2500".repeat(pidWidth + stateWidth + commandWidth + 2);
+  const rows = processes.map((p) => {
+    const command = p.command || "unknown";
+    const truncated = command.length > commandWidth ? command.substring(0, commandWidth - 3) + "..." : command;
+    return `${p.pid.toString().padEnd(pidWidth)} ${p.state.padEnd(stateWidth)} ${truncated}`;
+  });
+  return `${header}
+${separator}
+${rows.join(`
+`)}`;
+}
+async function listPort(port, options = {}) {
+  const { verbose = false } = options;
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`Invalid port number: ${port}. Port must be between 1 and 65535.`);
+  }
+  const os = platform();
+  if (verbose)
+    console.log(`Searching for processes on port ${port} (${os})...
+`);
+  let processes = [];
+  if (os === "win32") {
+    processes = getProcessesOnWindowsPort(port);
+  } else {
+    processes = getProcessesOnLinuxPort(port);
+  }
+  return processes;
+}
+if (import.meta.url.endsWith(process.argv[1]?.replace(/\\/g, "/"))) {
+  const args = process.argv.slice(2);
+  if (args.includes("--help") || args.includes("-h") || args.length === 0) {
+    console.log("Usage: list-port <port> [options]");
+    console.log("List process(es) running on a specified port (Windows & Linux support)");
+    console.log();
+    console.log("Arguments:");
+    console.log("  port                  Port number (1-65535)");
+    console.log();
+    console.log("Options:");
+    console.log("  -v, --verbose         Show verbose output");
+    console.log("  -h, --help            Show this help message");
+    console.log();
+    console.log("Examples:");
+    console.log("  hlpr process list-port 3000");
+    console.log("  hlpr process list-port 8080 --verbose");
+    console.log("  hlpr process list-port 5432 -v");
+    process.exit(0);
+  }
+  const port = parseInt(args[0], 10);
+  const verbose = args.includes("-v") || args.includes("--verbose");
+  listPort(port, { verbose }).then((processes) => {
+    console.log(formatTable(processes));
+    process.exit(processes.length === 0 ? 1 : 0);
+  }).catch((error) => {
+    console.error("Error:", error.message);
+    process.exit(1);
+  });
+}
+var list_port_default = { listPort };
+export {
+  listPort,
+  list_port_default as default
+};

package/bin/index.js

@@ -23,7 +23,7 @@ async function getVersion() {
 function detectShell() {
   const isWindows = os.platform() === "win32";
   if (isWindows) {
-    return "bash";
+    return "powershell";
   }
   return "bash";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tertium/hlpr",
-  "version": "0.5.8",
+  "version": "0.6.0",
   "description": "Windows and *Nix utility for typical programming activity",
   "author": "Vitalii Balabanov",
   "email": "tertiumnon@gmail.com",
@@ -8,22 +8,21 @@
   "type": "module",
   "scripts": {
     "build:main": "bun build ./src/index.ts --outfile ./bin/index.js --target node",
-    "build:commands": "bun build-commands.js",
+    "build:commands": "bun scripts/build-commands/build-commands.ts",
     "build": "bun run build:main && bun run build:commands",
     "test": "bun test",
-    "test:e2e": "bun scripts/test-rename-e2e.cjs",
+    "test:e2e": "bun scripts/test-rename/test-rename.ts",
     "prepublishOnly": "bun run build",
-    "release:minor": "bun node_modules/@tertium/js/scripts/release.js minor",
     "release:patch": "bun node_modules/@tertium/js/scripts/release.js patch",
+    "release:minor": "bun node_modules/@tertium/js/scripts/release.js minor",
     "release:major": "bun node_modules/@tertium/js/scripts/release.js major",
-    "prepare": "husky"
+    "setup:hooks": "git config core.hooksPath .githooks"
   },
   "dependencies": {
     "@tertium/js": "^1.4.7"
   },
   "devDependencies": {
     "@types/node": "^22.13.10",
-    "husky": "^9.1.7",
     "typescript": "^5.8.3"
   },
   "bin": {