@tertium/hlpr 0.2.0 → 0.3.2

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

@@ -0,0 +1,157 @@
+// src/commands/file/rename/rename.ts
+import fs from "fs/promises";
+import path from "path";
+function splitWords(s) {
+  const parts = s.replace(/([a-z])([A-Z])/g, "$1 $2").split(/[^\p{L}\p{N}]+/u).map((p) => p.trim()).filter(Boolean);
+  return parts;
+}
+function transformBasename(basename, style) {
+  if (!basename)
+    return basename;
+  if (basename.includes(".") && !basename.startsWith("."))
+    return basename;
+  const leadingDot = basename.startsWith(".") ? "." : "";
+  const core = leadingDot ? basename.slice(1) : basename;
+  const words = splitWords(core);
+  if (words.length === 0)
+    return basename;
+  switch (style) {
+    case "title_underscore":
+      return leadingDot + words.map(cap).join("_");
+    case "snake":
+      return leadingDot + words.map((w) => w.toLowerCase()).join("_");
+    case "kebab":
+      return leadingDot + words.map((w) => w.toLowerCase()).join("-");
+    case "camel":
+      return leadingDot + words.map((w, i) => i === 0 ? w.toLowerCase() : cap(w)).join("");
+    case "pascal":
+      return leadingDot + words.map(cap).join("");
+    case "upper":
+      return leadingDot + words.join("_").toUpperCase();
+    case "lower":
+      return leadingDot + words.join("_").toLowerCase();
+    default:
+      return basename;
+  }
+}
+function cap(s) {
+  if (!s)
+    return s;
+  return s[0].toUpperCase() + s.slice(1).toLowerCase();
+}
+async function exists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function uniqueDestination(dest) {
+  if (!await exists(dest))
+    return dest;
+  const dir = path.dirname(dest);
+  const parsed = path.parse(dest);
+  let i = 1;
+  while (true) {
+    const candidate = path.join(dir, `${parsed.name}_${i}${parsed.ext}`);
+    if (!await exists(candidate))
+      return candidate;
+    i++;
+  }
+}
+async function safeRename(oldPath, newPath) {
+  const oldLower = oldPath.toLowerCase();
+  const newLower = newPath.toLowerCase();
+  if (oldLower === newLower && oldPath !== newPath) {
+    const tmp = newPath + "__tmp_renaming__";
+    await fs.rename(oldPath, tmp);
+    try {
+      await fs.rename(tmp, newPath);
+    } catch (err) {
+      await fs.rename(tmp, oldPath).catch(() => {});
+      throw err;
+    }
+  } else {
+    const final = await uniqueDestination(newPath);
+    if (final !== newPath) {
+      await fs.rename(oldPath, final);
+    } else {
+      await fs.rename(oldPath, newPath);
+    }
+  }
+}
+async function renameRecursive(root, style = "title_underscore", options = {}) {
+  const performed = [];
+  async function walk(current) {
+    const entries = await fs.readdir(current, { withFileTypes: true });
+    for (const e of entries) {
+      const full = path.join(current, e.name);
+      if (e.isFile()) {
+        const parsed = path.parse(e.name);
+        const newBase = transformBasename(parsed.name, style) + parsed.ext;
+        if (newBase !== e.name) {
+          const dest = path.join(current, newBase);
+          if (options.dryRun) {
+            performed.push({ from: full, to: dest });
+          } else {
+            await safeRename(full, dest);
+            performed.push({ from: full, to: dest });
+          }
+        }
+      }
+    }
+    const entries2 = await fs.readdir(current, { withFileTypes: true });
+    for (const e of entries2) {
+      const full = path.join(current, e.name);
+      if (e.isDirectory()) {
+        await walk(full);
+        const newBase = transformBasename(e.name, style);
+        if (newBase !== e.name) {
+          const dest = path.join(current, newBase);
+          if (options.dryRun) {
+            performed.push({ from: full, to: dest });
+          } else {
+            await safeRename(full, dest);
+            performed.push({ from: full, to: dest });
+          }
+        }
+      }
+    }
+  }
+  await walk(root);
+  return performed;
+}
+if (import.meta.url.endsWith(process.argv[1]?.replace(/\\/g, "/"))) {
+  const args = process.argv.slice(2);
+  const rootArg = args[0];
+  const styleArg = args[1];
+  const dryRun = args.includes("--dry") || args.includes("-n");
+  if (!rootArg || !styleArg) {
+    console.error("Usage: rename <root> <style> [--dry|-n]");
+    console.error("Styles: title_underscore, snake, kebab, camel, pascal, upper, lower");
+    process.exit(1);
+  }
+  renameRecursive(rootArg, styleArg, { dryRun }).then((performed) => {
+    if (dryRun) {
+      console.log(`Dry run - would rename ${performed.length} items:`);
+    } else {
+      console.log(`Renamed ${performed.length} items:`);
+    }
+    performed.forEach(({ from, to }) => {
+      console.log(`  ${from} → ${to}`);
+    });
+  }).catch((err) => {
+    console.error("Error:", err);
+    process.exit(1);
+  });
+}
+var rename_default = {
+  transformBasename,
+  renameRecursive
+};
+export {
+  transformBasename,
+  renameRecursive,
+  rename_default as default
+};

package/bin/commands/git/fodd.sh

@@ -0,0 +1 @@
+git fetch origin develop:develop

package/bin/commands/git/precommit.sh

@@ -0,0 +1,3 @@
+echo "Running build before commit..."
+bun run build
+git add bin/

package/bin/commands/hello/world.sh

@@ -0,0 +1 @@
+echo "Hello World, {{name}}"

package/bin/commands/help/help.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/commands/help/help.ts
+import * as path from "path";
+import * as fs from "fs";
+import { fileURLToPath } from "url";
+import { readFile } from "fs/promises";
+async function getVersion() {
+  try {
+    const __filename2 = fileURLToPath(import.meta.url);
+    const __dirname2 = path.dirname(__filename2);
+    const packagePath = path.join(__dirname2, "..", "..", "package.json");
+    const packageJson = JSON.parse(await readFile(packagePath, "utf-8"));
+    return packageJson.version;
+  } catch (error) {
+    return "0.0.0";
+  }
+}
+async function getCommandDescription(filePath) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    const descMatch = content.match(/(?:\/\/|#)\s*@description\s+(.+)/);
+    if (descMatch) {
+      return descMatch[1].trim();
+    }
+    const dir = path.dirname(filePath);
+    const readmePath = path.join(dir, "README.md");
+    if (fs.existsSync(readmePath)) {
+      const readme = await readFile(readmePath, "utf-8");
+      const firstLine = readme.split(`
+`).find((line) => line.trim() && !line.startsWith("#"));
+      if (firstLine) {
+        return firstLine.trim();
+      }
+    }
+  } catch (error) {}
+  return;
+}
+async function discoverCommands(commandsDir) {
+  const commands = [];
+  try {
+    const categories = await fs.promises.readdir(commandsDir, { withFileTypes: true });
+    for (const category of categories) {
+      if (!category.isDirectory())
+        continue;
+      const categoryPath = path.join(commandsDir, category.name);
+      const items = await fs.promises.readdir(categoryPath, { withFileTypes: true });
+      for (const item of items) {
+        if (item.isDirectory()) {
+          const nestedJsPath = path.join(categoryPath, item.name, `${item.name}.js`);
+          const nestedShPath = path.join(categoryPath, item.name, `${item.name}.sh`);
+          let commandPath;
+          let commandType;
+          if (fs.existsSync(nestedJsPath)) {
+            commandPath = nestedJsPath;
+            commandType = "typescript";
+          } else if (fs.existsSync(nestedShPath)) {
+            commandPath = nestedShPath;
+            commandType = "shell";
+          } else {
+            continue;
+          }
+          const description = await getCommandDescription(commandPath);
+          commands.push({
+            category: category.name,
+            name: item.name,
+            type: commandType,
+            path: commandPath,
+            description
+          });
+        } else if (item.name.endsWith(".js")) {
+          const jsPath = path.join(categoryPath, item.name);
+          const commandName = path.basename(item.name, ".js");
+          if (commandName !== "test" && !commandName.endsWith(".test")) {
+            const description = await getCommandDescription(jsPath);
+            commands.push({
+              category: category.name,
+              name: commandName,
+              type: "typescript",
+              path: jsPath,
+              description
+            });
+          }
+        } else if (item.name.endsWith(".sh")) {
+          const shPath = path.join(categoryPath, item.name);
+          const commandName = path.basename(item.name, ".sh");
+          const description = await getCommandDescription(shPath);
+          commands.push({
+            category: category.name,
+            name: commandName,
+            type: "shell",
+            path: shPath,
+            description
+          });
+        }
+      }
+    }
+  } catch (error) {
+    console.error("Error discovering commands:", error);
+  }
+  return commands;
+}
+function printHelp(commands, version) {
+  console.log(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557`);
+  console.log(`\u2551              hlpr - Helper CLI Tool v${version.padEnd(16)}\u2551`);
+  console.log(`\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`);
+  console.log("USAGE:");
+  console.log(`  hlpr [options] <category> <command> [args...]
+`);
+  console.log("OPTIONS:");
+  console.log("  -f              Force execution (continue on errors)");
+  console.log("  -v, --version   Show version information");
+  console.log("  help, -h, --help, /h, /help, /?");
+  console.log(`                  Show this help message
+`);
+  console.log(`AVAILABLE COMMANDS:
+`);
+  const grouped = commands.reduce((acc, cmd) => {
+    if (!acc[cmd.category]) {
+      acc[cmd.category] = [];
+    }
+    acc[cmd.category].push(cmd);
+    return acc;
+  }, {});
+  const sortedCategories = Object.keys(grouped).sort();
+  for (const category of sortedCategories) {
+    console.log(`  ${category}:`);
+    const categoryCommands = grouped[category].sort((a, b) => a.name.localeCompare(b.name));
+    for (const cmd of categoryCommands) {
+      const typeLabel = cmd.type === "typescript" ? "(TS)" : "(sh)";
+      const cmdDisplay = cmd.category === cmd.name ? `hlpr ${cmd.name}`.padEnd(35) : `hlpr ${cmd.category} ${cmd.name}`.padEnd(35);
+      if (cmd.description) {
+        console.log(`    ${cmdDisplay} ${typeLabel.padEnd(6)} ${cmd.description}`);
+      } else {
+        console.log(`    ${cmdDisplay} ${typeLabel}`);
+      }
+    }
+    console.log("");
+  }
+  console.log("EXAMPLES:");
+  console.log("  hlpr help");
+  console.log("  hlpr file rename --style kebab --dir ./src");
+  console.log("  hlpr ssh init-dir");
+  console.log(`  hlpr -f git precommit
+`);
+}
+async function main() {
+  try {
+    const __filename2 = fileURLToPath(import.meta.url);
+    const __dirname2 = path.dirname(__filename2);
+    const binCommandsDir = path.join(__dirname2, "..");
+    const srcCommandsDir = path.join(__dirname2, "..", "..", "..", "src", "commands");
+    const version = await getVersion();
+    const commands = [
+      ...await discoverCommands(binCommandsDir),
+      ...await discoverCommands(srcCommandsDir)
+    ];
+    const uniqueCommands = commands.filter((cmd, index, self) => index === self.findIndex((c) => c.category === cmd.category && c.name === cmd.name));
+    printHelp(uniqueCommands, version);
+  } catch (error) {
+    console.error("Error:", error);
+    process.exit(1);
+  }
+}
+main();

package/bin/commands/nvm/install.sh

@@ -0,0 +1 @@
+curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash

package/bin/commands/nvm/lts.sh

@@ -0,0 +1,2 @@
+nvm install --lts
+nvm use --lts

package/bin/commands/ssh/init-dir.sh

@@ -0,0 +1,6 @@
+mkdir ~/.ssh
+touch ~/.ssh/known_hosts
+touch ~/.ssh/config
+chmod 700 ~/.ssh
+chmod 644 ~/.ssh/known_hosts
+chmod 644 ~/.ssh/config

package/{index.js → bin/index.js}

@@ -25,6 +25,9 @@ function detectShell() {
   }
   return "bash";
 }
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path.dirname(__filename2);
+var scriptDir = path.join(__dirname2, "..", "src");
 var args = process.argv.slice(2);
 var forceFlag = false;
 var commandArgs = [];
@@ -79,38 +82,49 @@ async function main() {
     console.log(`hlpr version ${version}`);
     process.exit(0);
   }
-  if (commandArgs.length === 0) {
-    console.error("Please provide a command. Example: hlpr ssh init-dir");
-    process.exit(1);
+  if (commandArgs.length === 0 || commandArgs[0] === "help" || commandArgs[0] === "--help" || commandArgs[0] === "-h" || commandArgs[0] === "/help" || commandArgs[0] === "/h" || commandArgs[0] === "/?") {
+    const helpScriptPath = path.join(__dirname2, "..", "bin", "commands", "help", "help.js");
+    if (fs.existsSync(helpScriptPath)) {
+      const helpCommand = `node "${helpScriptPath}"`;
+      await executeCommand(helpCommand, {});
+      rl.close();
+      process.exit(0);
+    } else {
+      console.error("Please provide a command. Example: hlpr ssh init-dir");
+      console.error("Run 'hlpr help' for available commands.");
+      process.exit(1);
+    }
   }
   try {
     const category = commandArgs[0];
     const restArgs = commandArgs.slice(1);
-    const __filename2 = fileURLToPath(import.meta.url);
-    const __dirname2 = path.dirname(__filename2);
-    const scriptDir = __dirname2;
     let scriptPath;
     let isTypeScriptCommand = false;
     if (restArgs.length > 0) {
       const subcategory = restArgs[0];
-      const nestedTsPath = path.join(scriptDir, "commands", category, subcategory, `${subcategory}.ts`);
-      if (fs.existsSync(nestedTsPath)) {
-        scriptPath = nestedTsPath;
+      const nestedJsPath = path.join(__dirname2, "..", "bin", "commands", category, subcategory, `${subcategory}.js`);
+      if (fs.existsSync(nestedJsPath)) {
+        scriptPath = nestedJsPath;
         isTypeScriptCommand = true;
       }
     }
     if (!isTypeScriptCommand) {
-      const tsPath = path.join(scriptDir, "commands", category, `${category}.ts`);
-      if (fs.existsSync(tsPath)) {
-        scriptPath = tsPath;
+      const jsPath = path.join(__dirname2, "..", "bin", "commands", category, `${category}.js`);
+      if (fs.existsSync(jsPath)) {
+        scriptPath = jsPath;
         isTypeScriptCommand = true;
       }
     }
     if (!isTypeScriptCommand && restArgs.length > 0) {
       const scriptName = restArgs.join("");
-      scriptPath = path.join(scriptDir, "commands", category, `${scriptName}.sh`);
-      if (!fs.existsSync(scriptPath)) {
-        console.error(`Script not found: ${scriptPath}`);
+      let scriptPathCandidate = path.join(scriptDir, "commands", category, `${scriptName}.sh`);
+      if (!fs.existsSync(scriptPathCandidate)) {
+        scriptPathCandidate = path.join(__dirname2, "..", "bin", "commands", category, `${scriptName}.sh`);
+      }
+      if (fs.existsSync(scriptPathCandidate)) {
+        scriptPath = scriptPathCandidate;
+      } else {
+        console.error(`Script not found: ${scriptPathCandidate}`);
         process.exit(1);
       }
     }
@@ -120,8 +134,8 @@ async function main() {
     }
     if (isTypeScriptCommand) {
       const tsArgs = restArgs.length > 0 && restArgs[0] && fs.existsSync(path.join(scriptDir, "commands", category, restArgs[0])) ? process.argv.slice(4) : process.argv.slice(3);
-      const finalCommand = `bun "${scriptPath}" ${tsArgs.join(" ")}`;
-      console.log(`Executing TypeScript command: ${finalCommand}`);
+      const finalCommand = `node "${scriptPath}" ${tsArgs.join(" ")}`;
+      console.log(`Executing command: ${finalCommand}`);
       const success2 = await executeCommand(finalCommand, {});
       if (!success2 && !forceFlag) {
         console.error("Command failed, stopping execution.");

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "@tertium/hlpr",
-  "version": "0.2.0",
+  "version": "0.3.2",
   "description": "Windows and *Nix utility for typical programming activity",
   "author": "Vitalii Balabanov",
   "email": "tertiumnon@gmail.com",
-  "main": "index.js",
+  "main": "bin/index.js",
   "type": "module",
   "scripts": {
-    "build": "bun build ./src/index.ts --outfile ./index.js --target node",
+    "build:main": "bun build ./src/index.ts --outfile ./bin/index.js --target node",
+    "build:commands": "node build-commands.js",
+    "build": "bun run build:main && bun run build:commands",
+    "test": "bun test",
     "prepublishOnly": "npm run build",
     "release:minor": "node node_modules/@tertium/js/scripts/release.js minor",
     "release:patch": "node node_modules/@tertium/js/scripts/release.js patch",
@@ -21,11 +24,10 @@
     "typescript": "^5.8.3"
   },
   "bin": {
-    "hlpr": "./bin/hlpr.js"
+    "hlpr": "./bin/index.js"
   },
   "files": [
     "bin",
-    "index.js",
     "package.json"
   ],
   "keywords": [

package/bin/hlpr.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-
-import { main } from '../index.js';
-main();