xw-devtool-cli 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xw-devtool-cli",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "type": "module",
   "description": "基于node的开发者助手cli",
   "main": "index.js",
@@ -51,7 +51,9 @@
     "inquirer": "^13.1.0",
     "lorem-ipsum": "^2.0.8",
     "pinyin": "^4.0.0",
+    "qrcode": "^1.5.4",
     "sharp": "^0.33.5",
+    "tinycolor2": "^1.6.0",
     "uuid": "^13.0.0"
   }
 }

package/src/commands/color.js

@@ -0,0 +1,56 @@
+import inquirer from 'inquirer';
+import tinycolor from 'tinycolor2';
+import { copy } from '../utils/clipboard.js';
+import { selectFromMenu } from '../utils/menu.js';
+
+export async function colorHandler() {
+    const { input } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'input',
+            message: 'Enter color (Hex, RGB, HSL, or Name):',
+            validate: (input) => {
+                const color = tinycolor(input);
+                return color.isValid() || 'Invalid color format';
+            }
+        }
+    ]);
+
+    const color = tinycolor(input);
+    
+    const results = [];
+    results.push(`Hex: ${color.toHexString().toUpperCase()}`);
+    results.push(`RGB: ${color.toRgbString()}`);
+    results.push(`HSL: ${color.toHslString()}`);
+    results.push(`HSV: ${color.toHsvString()}`);
+    
+    // CMYK conversion (manual, as tinycolor doesn't support it directly)
+    const rgb = color.toRgb();
+    const r = rgb.r / 255;
+    const g = rgb.g / 255;
+    const b = rgb.b / 255;
+    let k = 1 - Math.max(r, g, b);
+    let c = (1 - r - k) / (1 - k) || 0;
+    let m = (1 - g - k) / (1 - k) || 0;
+    let y = (1 - b - k) / (1 - k) || 0;
+    
+    // Round to 2 decimal places
+    const toPercent = (n) => Math.round(n * 100);
+    const cmyk = `cmyk(${toPercent(c)}%, ${toPercent(m)}%, ${toPercent(y)}%, ${toPercent(k)}%)`;
+    results.push(`CMYK: ${cmyk}`);
+
+    console.log('\n=== Conversion Results ===');
+    results.forEach(res => console.log(res));
+    console.log('==========================\n');
+
+    // Allow user to copy one of the formats
+    const copyChoice = await selectFromMenu('Select format to copy', [
+        { name: 'Hex', value: color.toHexString().toUpperCase() },
+        { name: 'RGB', value: color.toRgbString() },
+        { name: 'HSL', value: color.toHslString() },
+        { name: 'HSV', value: color.toHsvString() },
+        { name: 'CMYK', value: cmyk }
+    ]);
+
+    await copy(copyChoice);
+}

package/src/commands/hashing.js

@@ -0,0 +1,58 @@
+import inquirer from 'inquirer';
+import crypto from 'node:crypto';
+import { copy, read } from '../utils/clipboard.js';
+import { selectFromMenu } from '../utils/menu.js';
+
+export async function hashingHandler() {
+    const { input } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'input',
+            message: 'Enter text to hash (Press Enter to paste from clipboard):',
+        }
+    ]);
+
+    let textToHash = input;
+
+    if (!textToHash || textToHash.length === 0) {
+        textToHash = await read();
+        if (!textToHash || textToHash.length === 0) {
+             console.log('Clipboard is empty or could not be read.');
+             return;
+        }
+        console.log(`\nUsing clipboard content: "${textToHash}"`);
+    }
+
+    const algorithms = [
+        { name: 'MD5', algo: 'md5' },
+        { name: 'SHA1', algo: 'sha1' },
+        { name: 'SHA256', algo: 'sha256' },
+        { name: 'SHA512', algo: 'sha512' },
+        { name: 'SM3', algo: 'sm3' }
+    ];
+
+    const results = [];
+
+    console.log('\n=== Hash Results ===');
+    for (const { name, algo } of algorithms) {
+        try {
+            const hash = crypto.createHash(algo).update(textToHash).digest('hex');
+            results.push({ name, value: hash });
+            console.log(`${name.padEnd(8)}: ${hash}`);
+        } catch (e) {
+            console.log(`${name.padEnd(8)}: Not supported in this environment`);
+        }
+    }
+    console.log('====================\n');
+
+    if (results.length === 0) return;
+
+    const copyChoice = await selectFromMenu('Select hash to copy', 
+        results.map(r => ({
+            name: `${r.name} (${r.value.substring(0, 10)}...)`,
+            value: r.value
+        }))
+    );
+
+    await copy(copyChoice);
+}

package/src/commands/qrcode.js

@@ -0,0 +1,61 @@
+import inquirer from 'inquirer';
+import QRCode from 'qrcode';
+import fs from 'fs';
+import path from 'path';
+import dayjs from 'dayjs';
+import { read } from '../utils/clipboard.js';
+import { selectFromMenu } from '../utils/menu.js';
+
+export async function qrcodeHandler() {
+    const { input } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'input',
+            message: 'Enter text to generate QR code (Press Enter to paste from clipboard):',
+        }
+    ]);
+
+    let textToEncode = input;
+
+    if (!textToEncode || textToEncode.length === 0) {
+        textToEncode = await read();
+        if (!textToEncode || textToEncode.length === 0) {
+             console.log('Clipboard is empty or could not be read.');
+             return;
+        }
+        console.log(`\nUsing clipboard content: "${textToEncode}"`);
+    }
+
+    try {
+        // Display in terminal
+        const string = await QRCode.toString(textToEncode, { type: 'terminal', small: true });
+        console.log('\n=== QR Code ===\n');
+        console.log(string);
+        console.log('===============\n');
+
+        // Ask if user wants to save to file
+        const action = await selectFromMenu('What would you like to do next?', [
+            { name: 'Back to menu', value: 'back' },
+            { name: 'Save as PNG image', value: 'save' }
+        ]);
+
+        if (action === 'save') {
+            const defaultFilename = `qrcode_${dayjs().format('YYYYMMDD_HHmmss')}.png`;
+            const { filename } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'filename',
+                    message: `Enter filename (default: ${defaultFilename}):`,
+                    default: defaultFilename
+                }
+            ]);
+
+            const outputPath = path.resolve(process.cwd(), filename);
+            await QRCode.toFile(outputPath, textToEncode);
+            console.log(`\nQR Code saved to: ${outputPath}\n`);
+        }
+
+    } catch (err) {
+        console.error('Error generating QR code:', err.message);
+    }
+}

package/src/commands/timeFormat.js

@@ -1,6 +1,10 @@
 import inquirer from 'inquirer';
 import dayjs from 'dayjs';
+import 'dayjs/locale/zh-cn.js';
 import { copy } from '../utils/clipboard.js';
+import { selectFromMenu } from '../utils/menu.js';
+
+dayjs.locale('zh-cn');
 
 export async function timeFormatHandler() {
     const { input } = await inquirer.prompt([
@@ -35,7 +39,26 @@ export async function timeFormatHandler() {
         return;
     }
 
-    const formatted = date.format('YYYY-MM-DD HH:mm:ss');
+    const formatPattern = await selectFromMenu('Select Output Format', [
+        { name: 'YYYY-MM-DD HH:mm:ss', value: 'YYYY-MM-DD HH:mm:ss' },
+        { name: 'YYYY-MM-DD HH:mm', value: 'YYYY-MM-DD HH:mm' },
+        { name: 'YYYY-MM-DD', value: 'YYYY-MM-DD' },
+        { name: 'HH:mm:ss', value: 'HH:mm:ss' },
+        { name: 'YYYY-MM-DD HH:mm:ss dddd', value: 'YYYY-MM-DD HH:mm:ss dddd' },
+        { name: 'dddd', value: 'dddd' },
+        { name: 'Timestamp (ms)', value: 'timestamp-ms' },
+        { name: 'Timestamp (s)', value: 'timestamp-s' }
+    ]);
+
+    let formatted;
+    if (formatPattern === 'timestamp-ms') {
+        formatted = String(date.valueOf());
+    } else if (formatPattern === 'timestamp-s') {
+        formatted = String(date.unix());
+    } else {
+        formatted = date.format(formatPattern);
+    }
+    
     console.log(`\nFormatted: ${formatted}\n`);
     await copy(formatted);
 }

package/src/commands/variableFormat.js

@@ -0,0 +1,94 @@
+import inquirer from 'inquirer';
+import { copy, read } from '../utils/clipboard.js';
+import { selectFromMenu } from '../utils/menu.js';
+
+export async function variableFormatHandler() {
+    const { input } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'input',
+            message: 'Enter variable name to convert (Press Enter to paste from clipboard):',
+        }
+    ]);
+
+    let textToConvert = input;
+
+    if (!textToConvert || textToConvert.trim().length === 0) {
+        textToConvert = await read();
+        if (!textToConvert || textToConvert.trim().length === 0) {
+             console.log('Clipboard is empty or could not be read.');
+             return;
+        }
+        console.log(`\nUsing clipboard content: "${textToConvert}"`);
+    }
+
+    const words = splitIntoWords(textToConvert);
+    
+    if (words.length === 0) {
+        console.log('Could not parse any words from input.');
+        return;
+    }
+
+    const results = {
+        'camelCase': toCamelCase(words),
+        'PascalCase': toPascalCase(words),
+        'snake_case': toSnakeCase(words),
+        'kebab-case': toKebabCase(words),
+        'CONSTANT_CASE': toConstantCase(words)
+    };
+
+    console.log('\n=== Conversion Results ===');
+    Object.entries(results).forEach(([key, value]) => {
+        console.log(`${key.padEnd(15)}: ${value}`);
+    });
+    console.log('==========================\n');
+
+    const copyChoice = await selectFromMenu('Select format to copy', 
+        Object.entries(results).map(([key, value]) => ({
+            name: `${key} (${value})`,
+            value: value
+        }))
+    );
+
+    await copy(copyChoice);
+}
+
+function splitIntoWords(str) {
+    // 1. Handle CamelCase/camelCase by inserting space before uppercase letters that follow lowercase letters
+    let temp = str.replace(/([a-z])([A-Z])/g, '$1 $2');
+    
+    // 2. Handle consecutive uppercase followed by lowercase (e.g. JSONParser -> JSON Parser)
+    temp = temp.replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2');
+
+    // 3. Replace non-alphanumeric characters with spaces
+    temp = temp.replace(/[^a-zA-Z0-9]+/g, ' ');
+
+    // 4. Split by whitespace and filter empty strings
+    return temp
+        .trim()
+        .split(/\s+/)
+        .filter(w => w.length > 0);
+}
+
+function toCamelCase(words) {
+    return words.map((w, i) => {
+        if (i === 0) return w.toLowerCase();
+        return w.charAt(0).toUpperCase() + w.slice(1).toLowerCase();
+    }).join('');
+}
+
+function toPascalCase(words) {
+    return words.map(w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join('');
+}
+
+function toSnakeCase(words) {
+    return words.map(w => w.toLowerCase()).join('_');
+}
+
+function toKebabCase(words) {
+    return words.map(w => w.toLowerCase()).join('-');
+}
+
+function toConstantCase(words) {
+    return words.map(w => w.toUpperCase()).join('_');
+}

package/src/index.js

@@ -5,10 +5,13 @@ import { base64Handler } from './commands/base64.js';
 import { imgBase64Handler } from './commands/imgBase64.js';
 import { imgConvertHandler } from './commands/imgConvert.js';
 import { timeFormatHandler } from './commands/timeFormat.js';
-import { timestampHandler } from './commands/timestamp.js';
 import { mockHandler } from './commands/mock.js';
 import { uuidHandler } from './commands/uuid.js';
 import { pinyinHandler } from './commands/pinyin.js';
+import { colorHandler } from './commands/color.js';
+import { variableFormatHandler } from './commands/variableFormat.js';
+import { hashingHandler } from './commands/hashing.js';
+import { qrcodeHandler } from './commands/qrcode.js';
 
 process.on('SIGINT', () => {
     console.log('\nBye!');
@@ -30,11 +33,14 @@ const features = [
     { name: 'String Encode/Decode (Base64)', value: 'base64' },
     { name: 'Image <-> Base64', value: 'imgBase64' },
     { name: 'Image Format Convert', value: 'imgConvert' },
-    { name: 'Time Format', value: 'timeFormat' },
-    { name: 'Get Current Timestamp', value: 'timestamp' },
+    { name: 'Time Format / Timestamp', value: 'timeFormat' },
     { name: 'Mock Text', value: 'mock' },
     { name: 'Get UUID', value: 'uuid' },
-    { name: 'Chinese to Pinyin', value: 'pinyin' }
+    { name: 'Chinese to Pinyin', value: 'pinyin' },
+    { name: 'Color Converter (Hex <-> RGB)', value: 'color' },
+    { name: 'Variable Format Converter', value: 'variableFormat' },
+    { name: 'Hash Calculator (MD5/SHA/SM3)', value: 'hashing' },
+    { name: 'QR Code Generator', value: 'qrcode' }
 ];
 
 async function main() {
@@ -48,12 +54,29 @@ async function main() {
     program.parse(process.argv);
 }
 
+function getFeatureKey(index) {
+    if (index < 9) {
+        return String(index + 1);
+    }
+    return String.fromCharCode('a'.charCodeAt(0) + (index - 9));
+}
+
+function getFeatureIndex(key) {
+    if (/^[1-9]$/.test(key)) {
+        return parseInt(key) - 1;
+    }
+    if (/^[a-z]$/.test(key.toLowerCase())) {
+        return key.toLowerCase().charCodeAt(0) - 'a'.charCodeAt(0) + 9;
+    }
+    return -1;
+}
+
 async function showMenu() {
     console.log('\n=================================');
     console.log('      xw-devtool-cli Menu');
     console.log('=================================');
     features.forEach((feature, index) => {
-        console.log(`${index + 1}. ${feature.name}`);
+        console.log(`${getFeatureKey(index)}. ${feature.name}`);
     });
     console.log('0. Exit');
     console.log('=================================\n');
@@ -62,25 +85,26 @@ async function showMenu() {
         {
             type: 'input',
             name: 'choice',
-            message: 'Please enter the feature number (0-8):',
+            message: `Please enter the feature key (0-9, a-z):`,
             validate: (input) => {
-                const num = parseInt(input);
-                if (isNaN(num) || num < 0 || num > features.length) {
-                    return `Please enter a number between 0 and ${features.length}`;
+                if (input === '0') return true;
+                
+                const index = getFeatureIndex(input);
+                if (index >= 0 && index < features.length) {
+                    return true;
                 }
-                return true;
+                return 'Invalid selection. Please enter a valid menu key.';
             }
         }
     ]);
 
-    const index = parseInt(choice);
-
-    if (index === 0) {
+    if (choice === '0') {
         console.log('Bye!');
         process.exit(0);
     }
 
-    const selectedFeature = features[index - 1];
+    const index = getFeatureIndex(choice);
+    const selectedFeature = features[index];
     
     try {
         await handleAction(selectedFeature.value);
@@ -110,9 +134,6 @@ async function handleAction(action) {
         case 'timeFormat':
             await timeFormatHandler();
             break;
-        case 'timestamp':
-            await timestampHandler();
-            break;
         case 'mock':
             await mockHandler();
             break;
@@ -122,6 +143,18 @@ async function handleAction(action) {
         case 'pinyin':
             await pinyinHandler();
             break;
+        case 'color':
+            await colorHandler();
+            break;
+        case 'variableFormat':
+            await variableFormatHandler();
+            break;
+        case 'hashing':
+            await hashingHandler();
+            break;
+        case 'qrcode':
+            await qrcodeHandler();
+            break;
         default:
             console.log('Feature not implemented yet.');
     }

package/src/utils/clipboard.js

@@ -8,3 +8,12 @@ export async function copy(text) {
         console.error('Failed to copy to clipboard (might not be supported in this environment):', e.message);
     }
 }
+
+export async function read() {
+    try {
+        return await clipboardy.read();
+    } catch (e) {
+        console.error('Failed to read from clipboard:', e.message);
+        return '';
+    }
+}

package/src/commands/timestamp.js

@@ -1,7 +0,0 @@
-import { copy } from '../utils/clipboard.js';
-
-export async function timestampHandler() {
-    const now = Date.now();
-    console.log(`\nCurrent Timestamp: ${now}\n`);
-    await copy(String(now));
-}