@tertium/hlpr 0.1.11 → 0.1.12

package/.github/workflows/publish.yml

@@ -0,0 +1,35 @@
+name: Publish Package
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Bun
+        run: curl -fsSL https://bun.sh/install | bash
+
+      - name: Add Bun to PATH
+        run: echo "$HOME/.bun/bin" >> $GITHUB_PATH
+
+      - name: Use Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+          registry-url: "https://registry.npmjs.org/"
+
+      - name: Install dependencies
+        run: bun install
+
+      - name: Install dependencies
+        run: bun run build
+
+      - name: Publish to npm (with Bun)
+        run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.husky/pre-commit

@@ -0,0 +1,6 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+echo "Running build before commit..."
+bun run build
+git add bin/hlpr.js

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "cSpell.words": ["hlpr"]
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@tertium/hlpr",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "Windows and *Nix utility for typical programming activity",
   "author": "Vitalii Balabanov",
   "email": "tertiumnon@gmail.com",
-  "main": "bin/hlpr.js",
+  "main": "index.js",
   "type": "commonjs",
   "scripts": {
     "build": "bun build ./src/index.ts --outfile ./index.js --target node",
@@ -23,11 +23,6 @@
   "bin": {
     "hlpr": "./bin/hlpr.js"
   },
-  "files": [
-    "bin",
-    "commands",
-    "index.js"
-  ],
   "keywords": [
     "cli",
     "utility",

package/src/index.ts

@@ -0,0 +1,179 @@
+import { readFile } from "node:fs/promises";
+import { exec } from "node:child_process";
+import * as path from "node:path";
+import * as fs from "node:fs";
+import * as readline from "node:readline";
+import * as os from "node:os";
+
+// Get package version from package.json
+async function getVersion(): Promise<string> {
+  try {
+    const packagePath = path.join(path.dirname(path.dirname(__dirname)), 'package.json');
+    const packageJson = JSON.parse(await readFile(packagePath, 'utf-8'));
+    return packageJson.version;
+  } catch (error) {
+    console.error('Error reading package.json:', error);
+    return '0.0.0'; // Fallback version
+  }
+}
+
+// Detect shell type
+function detectShell(): string {
+  const isWindows = os.platform() === "win32";
+  if (isWindows) {
+    return "powershell";
+  }
+  return "bash"; // Default to bash for Unix-like systems
+}
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+let forceFlag = false;
+let commandArgs: string[] = [];
+
+// Check for -f flag
+if (args[0] === "-f") {
+  forceFlag = true;
+  commandArgs = args.slice(1);
+} else {
+  commandArgs = args;
+}
+
+// Create readline interface for user input
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+// Prompt for user input
+function prompt(question: string): Promise<string> {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      resolve(answer);
+    });
+  });
+}
+
+// Execute a command with variable substitution
+async function executeCommand(command: string, variables: Record<string, string>): Promise<boolean> {
+  // Replace variables in the command
+  let processedCommand = command;
+  for (const [key, value] of Object.entries(variables)) {
+    processedCommand = processedCommand.replace(new RegExp(`{{${key}}}`, 'g'), value);
+  }
+
+  return new Promise((resolve) => {
+    console.log(`Executing: ${processedCommand}`);
+    const childProcess = exec(processedCommand);
+    
+    if (childProcess.stdout) {
+      childProcess.stdout.on("data", (data: string) => {
+        console.log(data.toString().trim());
+      });
+    }
+    
+    if (childProcess.stderr) {
+      childProcess.stderr.on("data", (data: string) => {
+        console.error(data.toString().trim());
+      });
+    }
+    
+    childProcess.on("exit", (code: number | null) => {
+      if (code === 0) {
+        resolve(true);
+      } else {
+        console.error(`Command failed with exit code ${code}`);
+        resolve(false);
+      }
+    });
+  });
+}
+
+export async function main() {
+  // Check for version flag
+  if (commandArgs[0] === "--version" || commandArgs[0] === "-v") {
+    const version = await getVersion();
+    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);
+  }
+
+  try {
+    // Get the category (first argument) and the rest of the command
+    const category = commandArgs[0];
+    const restArgs = commandArgs.slice(1);
+    
+    // Join the rest of the arguments without hyphens
+    const scriptName = restArgs.join("");
+    
+    // Get the directory where the hlpr script is installed
+    const scriptDir = path.dirname(path.dirname(__dirname));
+    const scriptPath = path.join(scriptDir, "commands", category, `${scriptName}.sh`);
+    
+    // Check if the script exists
+    if (!fs.existsSync(scriptPath)) {
+      console.error(`Script not found: ${scriptPath}`);
+      process.exit(1);
+    }
+
+    // Read the script content
+    const scriptContent = await readFile(scriptPath, "utf-8");
+    
+    // Extract variables from the script (anything in {{variable}})
+    const variableRegex = /{{([^}]+)}}/g;
+    const variables: Record<string, string> = {};
+    const uniqueVars = new Set<string>();
+    
+    let match;
+    while ((match = variableRegex.exec(scriptContent)) !== null) {
+      uniqueVars.add(match[1]);
+    }
+    
+    // Prompt for each variable
+    for (const varName of uniqueVars) {
+      const value = await prompt(`Enter ${varName}: `);
+      variables[varName] = value;
+    }
+    
+    // Create a temporary script with variables substituted
+    let processedScript = scriptContent;
+    for (const [key, value] of Object.entries(variables)) {
+      processedScript = processedScript.replace(new RegExp(`{{${key}}}`, 'g'), value);
+    }
+    
+    const tempScriptPath = path.join(path.dirname(scriptPath), `_temp_${path.basename(scriptPath)}`);
+    fs.writeFileSync(tempScriptPath, processedScript);
+    
+    // Execute the temporary script with appropriate shell
+    const shell = detectShell();
+    const command = shell === "powershell" 
+      ? `powershell -File "${tempScriptPath}"` 
+      : `bash "${tempScriptPath}"`;
+    const success = await executeCommand(command, {});
+    
+    // Clean up the temporary script
+    fs.unlinkSync(tempScriptPath);
+    
+    // If command failed and force flag is not set, exit
+    if (!success && !forceFlag) {
+      console.error("Command failed, stopping execution.");
+      process.exit(1);
+    }
+    
+    console.log("Command completed successfully!");
+  } catch (error) {
+    console.error("Error:", error);
+    process.exit(1);
+  } finally {
+    rl.close();
+  }
+}
+
+// If this file is run directly, execute main
+if (require.main === module) {
+  main();
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "outDir": "./bin",
+    "rootDir": "./",
+    "strict": true,
+    "declaration": false,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}