@allanpk716/work-skills-setup 0.1.0

package/bin/setup.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const { main } = require('../src/index.js');
+
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@allanpk716/work-skills-setup",
+  "version": "0.1.0",
+  "description": "Work Skills installer for Windows developers",
+  "main": "src/index.js",
+  "bin": {
+    "work-skills-setup": "./bin/setup.js"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "scripts": {
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "keywords": [
+    "claude-code",
+    "work-skills",
+    "installer",
+    "windows"
+  ],
+  "author": "allanpk716",
+  "license": "MIT",
+  "dependencies": {
+    "boxen": "^5.1.2",
+    "chalk": "^4.1.2",
+    "commander": "^14.0.3",
+    "enquirer": "^2.4.1",
+    "execa": "^5.1.1",
+    "winreg": "^1.2.5"
+  },
+  "devDependencies": {
+    "jest": "^30.3.0"
+  }
+}

package/src/cli.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const { Command } = require('commander');
+const { setLanguage } = require('./i18n/index.js');
+
+/**
+ * Parse command line arguments
+ * @param {string[]} argv - Process arguments (usually process.argv)
+ * @returns {Object} Parsed options
+ */
+function parseArgs(argv = process.argv) {
+  const packageJson = require('../package.json');
+
+  // Create a new Command instance for each call (avoids singleton issues in tests)
+  const program = new Command();
+
+  program
+    .name('work-skills-setup')
+    .description('Work Skills Setup - Claude Code skills installer for Windows developers')
+    .version(packageJson.version, '-v, --version', 'Show version')
+    .option('-l, --lang <locale>', 'Language (en/zh)', 'auto')
+    .option('--no-color', 'Disable colored output')
+    .option('--verify', 'Run installation verification only')
+    .allowExcessArguments(true)
+    .exitOverride() // Prevent process.exit in tests
+    .parse(argv);
+
+  const options = program.opts();
+
+  // Set language if specified
+  if (options.lang && options.lang !== 'auto') {
+    setLanguage(options.lang);
+  }
+
+  return {
+    lang: options.lang,
+    useColors: options.color !== false,
+    verifyOnly: options.verify === true
+  };
+}
+
+module.exports = {
+  parseArgs
+};

package/src/configurators/git-ssh.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const { Confirm } = require('enquirer');
+const execa = require('execa');
+const chalk = require('chalk');
+const { t } = require('../i18n/index.js');
+
+/**
+ * Detect Git SSH configuration
+ * @returns {Promise<{configured: boolean, command: string|null}>}
+ */
+async function detectGitSSH() {
+  try {
+    const { stdout } = await execa('git', ['config', '--get', 'core.sshCommand'], { reject: false });
+
+    if (stdout && stdout.trim()) {
+      return {
+        configured: true,
+        command: stdout.trim()
+      };
+    } else {
+      return {
+        configured: false,
+        command: null
+      };
+    }
+  } catch (error) {
+    return {
+      configured: false,
+      command: null
+    };
+  }
+}
+
+/**
+ * Configure Git SSH through interactive prompts and guidance
+ * @returns {Promise<{status: string, details: string}>}
+ */
+async function configureGitSSH() {
+  const current = await detectGitSSH();
+
+  // If already configured
+  if (current.configured) {
+    console.log(chalk.green(t('gitSSH.configured')));
+    console.log(chalk.gray(`  ${current.command}`));
+    return { status: 'configured', details: current.command };
+  }
+
+  // Show guidance
+  console.log(chalk.yellow(t('gitSSH.notConfigured')));
+  console.log(chalk.gray(t('gitSSH.recommended')));
+  console.log('');
+  console.log(chalk.bold(t('gitSSH.guidance')));
+  console.log(chalk.gray(t('gitSSH.step1')));
+  console.log(chalk.gray(t('gitSSH.step2')));
+  console.log(chalk.gray(t('gitSSH.step3')));
+  console.log(chalk.gray(t('gitSSH.step4')));
+  console.log(chalk.cyan(t('gitSSH.command')));
+  console.log('');
+  console.log(chalk.gray(t('gitSSH.docs')));
+  console.log('');
+
+  // Ask if user wants to skip
+  const skipPrompt = new Confirm({
+    name: 'skip',
+    message: t('gitSSH.promptSkip'),
+    initial: true
+  });
+
+  const shouldSkip = await skipPrompt.run();
+
+  if (shouldSkip) {
+    console.log(chalk.yellow(t('gitSSH.skipped')));
+    return { status: 'skipped', details: 'user skipped' };
+  }
+
+  // User will configure manually
+  return { status: 'configured', details: 'guidance shown' };
+}
+
+module.exports = {
+  detectGitSSH,
+  configureGitSSH
+};

package/src/configurators/git-user.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const { Input } = require('enquirer');
+const execa = require('execa');
+const chalk = require('chalk');
+const { t } = require('../i18n/index.js');
+
+/**
+ * Detect Git user.name and user.email configuration
+ * @returns {Promise<{name: string|null, email: string|null}>}
+ */
+async function detectGitUser() {
+  try {
+    const { stdout: name } = await execa('git', ['config', '--global', '--get', 'user.name'], { reject: false });
+    const { stdout: email } = await execa('git', ['config', '--global', '--get', 'user.email'], { reject: false });
+
+    return {
+      name: name || null,
+      email: email || null
+    };
+  } catch (error) {
+    return {
+      name: null,
+      email: null
+    };
+  }
+}
+
+/**
+ * Configure Git user information through interactive prompts
+ * @returns {Promise<{status: string, name?: string, email?: string}>}
+ */
+async function configureGitUser() {
+  const current = await detectGitUser();
+
+  // If already configured
+  if (current.name && current.email) {
+    console.log(chalk.green(t('gitUser.alreadyConfigured')));
+    console.log(chalk.gray(`  user.name: ${current.name}`));
+    console.log(chalk.gray(`  user.email: ${current.email}`));
+    return { status: 'configured', name: current.name, email: current.email };
+  }
+
+  // Show requirement
+  console.log(chalk.yellow(t('gitUser.required')));
+
+  // Prompt for user.name
+  const namePrompt = new Input({
+    name: 'userName',
+    message: t('gitUser.promptName')
+  });
+  const userName = await namePrompt.run();
+
+  // Prompt for user.email
+  const emailPrompt = new Input({
+    name: 'userEmail',
+    message: t('gitUser.promptEmail')
+  });
+  const userEmail = await emailPrompt.run();
+
+  // Set Git config
+  try {
+    await execa('git', ['config', '--global', 'user.name', userName]);
+    await execa('git', ['config', '--global', 'user.email', userEmail]);
+
+    console.log(chalk.green(t('gitUser.configured')));
+    return { status: 'configured', name: userName, email: userEmail };
+  } catch (error) {
+    console.log(chalk.red(t('gitUser.failed')));
+    console.log(chalk.gray(error.message));
+    return { status: 'failed' };
+  }
+}
+
+module.exports = {
+  detectGitUser,
+  configureGitUser
+};

package/src/configurators/index.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const chalk = require('chalk');
+const { t } = require('../i18n/index.js');
+const { configurePushover } = require('./pushover.js');
+const { configureGitSSH } = require('./git-ssh.js');
+const { configureGitUser } = require('./git-user.js');
+
+/**
+ * Display configuration summary table
+ * @param {Array<{name: string, status: string, details?: string}>} results
+ */
+function displayConfigSummary(results) {
+  console.log('\n' + chalk.bold(t('config.summary')));
+  console.log(chalk.gray('─'.repeat(60)));
+
+  results.forEach(result => {
+    let statusIcon, statusColor;
+
+    switch (result.status) {
+      case 'configured':
+        statusIcon = '✓';
+        statusColor = chalk.green;
+        break;
+      case 'skipped':
+        statusIcon = '⊘';
+        statusColor = chalk.yellow;
+        break;
+      case 'failed':
+        statusIcon = '✗';
+        statusColor = chalk.red;
+        break;
+      default:
+        statusIcon = '?';
+        statusColor = chalk.gray;
+    }
+
+    const statusText = t(`config.status.${result.status}`);
+    const details = result.details ? ` (${result.details})` : '';
+    console.log(`${statusColor(statusIcon)} ${result.name.padEnd(20)} ${statusColor(statusText)} ${chalk.gray(details)}`);
+  });
+
+  console.log(chalk.gray('─'.repeat(60)));
+}
+
+/**
+ * Run all configurators in sequence
+ * @returns {Promise<void>}
+ */
+async function runAllConfigurators() {
+  const results = [];
+
+  // 1. Pushover (optional)
+  console.log(chalk.bold('\n' + t('config.section.pushover')));
+  const pushoverResult = await configurePushover();
+  results.push({ name: 'Pushover', status: pushoverResult.status, details: pushoverResult.details });
+
+  // 2. Git SSH (optional)
+  console.log(chalk.bold('\n' + t('config.section.gitSSH')));
+  const sshResult = await configureGitSSH();
+  results.push({ name: 'Git SSH', status: sshResult.status, details: sshResult.details });
+
+  // 3. Git user.info (required)
+  console.log(chalk.bold('\n' + t('config.section.gitUser')));
+  const userResult = await configureGitUser();
+  results.push(
+    { name: 'Git user.name', status: userResult.status, details: userResult.name },
+    { name: 'Git user.email', status: userResult.status, details: userResult.email }
+  );
+
+  // Display summary
+  displayConfigSummary(results);
+}
+
+module.exports = {
+  runAllConfigurators,
+  displayConfigSummary
+};

package/src/configurators/pushover.js

@@ -0,0 +1,195 @@
+'use strict';
+
+const { Input, Confirm } = require('enquirer');
+const execa = require('execa');
+const chalk = require('chalk');
+const { t } = require('../i18n/index.js');
+
+/**
+ * Detect existing Pushover environment variables
+ * @returns {{token: string|null, user: string|null}}
+ */
+function detectPushoverEnv() {
+  return {
+    token: process.env.PUSHOVER_TOKEN || null,
+    user: process.env.PUSHOVER_USER || null
+  };
+}
+
+/**
+ * Set environment variable using setx command
+ * @param {string} name - Variable name
+ * @param {string} value - Variable value
+ * @returns {Promise<{success: boolean, error?: string, errorDetails?: string}>}
+ */
+async function setEnvVariable(name, value) {
+  try {
+    await execa('setx', [name, value]);
+    return { success: true };
+  } catch (error) {
+    const stderr = error.stderr || error.message || '';
+    let errorType = 'unknown';
+
+    // Detect error type from stderr
+    if (stderr.includes('Access is denied')) {
+      errorType = 'permission';
+    }
+
+    return {
+      success: false,
+      error: errorType,
+      errorDetails: stderr
+    };
+  }
+}
+
+/**
+ * Validate Pushover credentials against API
+ * @param {string} token - Pushover application token
+ * @param {string} user - Pushover user key
+ * @returns {Promise<{valid: boolean, devices?: Array, error?: string}>}
+ */
+async function validatePushoverCredentials(token, user) {
+  try {
+    const { stdout } = await execa('curl', [
+      '-s',
+      '-X',
+      'POST',
+      `https://api.pushover.net/1/users/validate.json`,
+      '-d',
+      `token=${token}`,
+      '-d',
+      `user=${user}`
+    ]);
+
+    const response = JSON.parse(stdout);
+
+    if (response.status === 1) {
+      return {
+        valid: true,
+        devices: response.devices || []
+      };
+    } else {
+      return {
+        valid: false,
+        error: response.errors?.join(', ') || 'Invalid credentials'
+      };
+    }
+  } catch (error) {
+    return {
+      valid: false,
+      error: error.message || 'Validation failed'
+    };
+  }
+}
+
+/**
+ * Configure Pushover through interactive prompts
+ * @param {number} maxRetries - Maximum retry attempts (default: 3)
+ * @returns {Promise<{status: string, details: string}>}
+ */
+async function configurePushover(maxRetries = 3) {
+  const currentEnv = detectPushoverEnv();
+
+  // Check if already configured
+  if (currentEnv.token && currentEnv.user) {
+    console.log(chalk.green(t('pushover.alreadyConfigured')));
+    console.log(chalk.gray(`  Token: ${currentEnv.token.substring(0, 8)}...`));
+    console.log(chalk.gray(`  User: ${currentEnv.user.substring(0, 8)}...`));
+
+    const reconfigurePrompt = new Confirm({
+      name: 'reconfigure',
+      message: t('pushover.promptReconfigure'),
+      initial: false
+    });
+
+    const shouldReconfigure = await reconfigurePrompt.run();
+    if (!shouldReconfigure) {
+      return { status: 'configured', details: 'already set' };
+    }
+  }
+
+  // Ask if user wants to configure Pushover
+  const configurePrompt = new Confirm({
+    name: 'configure',
+    message: t('pushover.promptConfigure'),
+    initial: true
+  });
+
+  const shouldConfigure = await configurePrompt.run();
+
+  if (!shouldConfigure) {
+    console.log(chalk.yellow(t('pushover.skipped')));
+    return { status: 'skipped', details: 'user skipped' };
+  }
+
+  // Retry loop
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    // Prompt for token
+    const tokenPrompt = new Input({
+      name: 'token',
+      message: t('pushover.promptToken')
+    });
+    const token = await tokenPrompt.run();
+
+    // Prompt for user
+    const userPrompt = new Input({
+      name: 'user',
+      message: t('pushover.promptUser')
+    });
+    const user = await userPrompt.run();
+
+    // Validate credentials
+    console.log(chalk.gray(t('pushover.validating')));
+    const validation = await validatePushoverCredentials(token, user);
+
+    if (!validation.valid) {
+      console.log(chalk.red(t('pushover.validationFailed')));
+      console.log(chalk.gray(`  -> ${validation.error}`));
+
+      if (attempt < maxRetries) {
+        console.log(chalk.yellow(t('pushover.retryPrompt', { attempt, max: maxRetries })));
+        continue;
+      } else {
+        return { status: 'failed', details: validation.error };
+      }
+    }
+
+    // Save credentials
+    console.log(chalk.gray(t('pushover.saving')));
+
+    const tokenResult = await setEnvVariable('PUSHOVER_TOKEN', token);
+    if (!tokenResult.success) {
+      console.log(chalk.red(t('pushover.saveFailed')));
+      console.log(chalk.gray(t('guidance.pushoverManual')));
+      return { status: 'failed', details: 'setx failed for token' };
+    }
+
+    const userResult = await setEnvVariable('PUSHOVER_USER', user);
+    if (!userResult.success) {
+      console.log(chalk.red(t('pushover.saveFailed')));
+      console.log(chalk.gray(t('guidance.pushoverManual')));
+      return { status: 'failed', details: 'setx failed for user' };
+    }
+
+    // Set environment variables for current process (immediate effect)
+    process.env.PUSHOVER_TOKEN = token;
+    process.env.PUSHOVER_USER = user;
+
+    // Success
+    console.log(chalk.green(t('pushover.configured')));
+    console.log(chalk.gray(t('pushover.currentSessionSet')));
+    console.log(chalk.yellow(t('pushover.restartReminder')));
+    return { status: 'configured', details: 'validated and saved' };
+  }
+
+  // Should not reach here, but just in case
+  return { status: 'failed', details: 'max retries exceeded' };
+}
+
+module.exports = {
+  detectPushoverEnv,
+  setEnvVariable,
+  validatePushoverCredentials,
+  configurePushover
+};

package/src/detectors/git.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const execa = require('execa');
+
+/**
+ * Detect Git installation and version
+ * @returns {Promise<{name: string, installed: boolean, version: string|null, meetsMinimum: boolean, command: string|null, guidance: string}>}
+ */
+async function detectGit() {
+  try {
+    const { stdout } = await execa('git', ['--version']);
+
+    // stdout: "git version 2.43.0.windows.1"
+    const versionMatch = stdout.match(/git version (\d+\.\d+\.\d+)/i);
+    const version = versionMatch ? versionMatch[1] : null;
+
+    return {
+      name: 'Git',
+      command: 'git',
+      installed: true,
+      version,
+      meetsMinimum: true, // Any Git version is acceptable
+      guidance: 'guidance.installGit'
+    };
+  } catch {
+    return {
+      name: 'Git',
+      command: null,
+      installed: false,
+      version: null,
+      meetsMinimum: false,
+      guidance: 'guidance.installGit'
+    };
+  }
+}
+
+module.exports = { detectGit };

package/src/detectors/index.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const chalk = require('chalk');
+const { t } = require('../i18n/index.js');
+const { detectPython } = require('./python.js');
+const { detectGit } = require('./git.js');
+const { detectSSHTools } = require('./ssh-tools.js');
+const { detectPipPackage } = require('./pip-package.js');
+
+/**
+ * Print detection result with status indicator
+ * @param {Object} result - Detection result object
+ */
+function printResult(result) {
+  const status = result.installed && result.meetsMinimum !== false;
+  const symbol = status ? chalk.green('[OK]') : chalk.red('[FAIL]');
+  const version = result.version ? ` (${result.version})` : '';
+
+  console.log(`  ${symbol} ${result.name}${version}`);
+
+  if (!status && result.guidance) {
+    console.log(chalk.gray(`      -> ${t(result.guidance)}`));
+  }
+}
+
+/**
+ * Run all environment detectors
+ * @returns {Promise<{results: Array, allPassed: boolean}>}
+ */
+async function runAllDetectors() {
+  console.log('\n' + t('detection.checking') + '\n');
+
+  const results = await Promise.all([
+    detectPython(),
+    detectGit(),
+    detectSSHTools(),
+    detectPipPackage('requests')
+  ]);
+
+  results.forEach(printResult);
+
+  const failedCount = results.filter(r => !r.installed || r.meetsMinimum === false).length;
+  const passedCount = results.length - failedCount;
+
+  console.log('\n' + t('detection.summary', { passed: passedCount, total: results.length }));
+
+  return {
+    results,
+    allPassed: failedCount === 0
+  };
+}
+
+module.exports = {
+  runAllDetectors,
+  printResult
+};

package/src/detectors/pip-package.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const execa = require('execa');
+
+/**
+ * Detect if a Python pip package is installed
+ * @param {string} packageName - Name of the package to detect
+ * @param {string} pythonCmd - Python command to use (default: 'python')
+ * @returns {Promise<{name: string, installed: boolean, version: string|null, meetsMinimum: boolean, guidance: string}>}
+ */
+async function detectPipPackage(packageName, pythonCmd = 'python') {
+  try {
+    const { stdout } = await execa(pythonCmd, ['-m', 'pip', 'show', packageName]);
+
+    // Parse pip show output for Name and Version
+    const nameMatch = stdout.match(/Name:\s*(.+)/i);
+    const versionMatch = stdout.match(/Version:\s*(.+)/i);
+
+    if (nameMatch) {
+      const version = versionMatch ? versionMatch[1].trim() : null;
+
+      return {
+        name: packageName,
+        installed: true,
+        version,
+        meetsMinimum: true, // Always true if installed
+        guidance: `guidance.install${packageName.charAt(0).toUpperCase() + packageName.slice(1)}`
+      };
+    }
+  } catch {
+    // Package not installed or pip not available
+  }
+
+  return {
+    name: packageName,
+    installed: false,
+    version: null,
+    meetsMinimum: false,
+    guidance: `guidance.install${packageName.charAt(0).toUpperCase() + packageName.slice(1)}`
+  };
+}
+
+module.exports = { detectPipPackage };