@allanpk716/work-skills-setup 0.1.0

package/src/marketplace/config-manager.js

@@ -0,0 +1,87 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Get Claude Code config.json path
+ * @returns {string} Full path to config.json
+ */
+function getConfigPath() {
+  return path.join(os.homedir(), '.claude', 'config.json');
+}
+
+/**
+ * Read Claude Code configuration
+ * @returns {Object} Parsed config object (empty object if file missing or invalid)
+ */
+function readClaudeConfig() {
+  const configPath = getConfigPath();
+
+  if (!fs.existsSync(configPath)) {
+    return {};
+  }
+
+  try {
+    const raw = fs.readFileSync(configPath, 'utf8');
+    return JSON.parse(raw);
+  } catch (error) {
+    // Parse error or read error - return empty config
+    return {};
+  }
+}
+
+/**
+ * Write Claude Code configuration
+ * @param {Object} config - Configuration object to write
+ */
+function writeClaudeConfig(config) {
+  const configPath = getConfigPath();
+
+  // Ensure directory exists
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+
+  // Write formatted JSON
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+
+/**
+ * Register work-skills as a marketplace source in Claude Code config
+ * @returns {{success: boolean, path: string, error?: string}}
+ */
+function registerMarketplaceSource() {
+  try {
+    const config = readClaudeConfig();
+
+    // Ensure marketplaceSources object exists
+    config.marketplaceSources = config.marketplaceSources || {};
+
+    // Add work-skills entry
+    config.marketplaceSources['work-skills'] = {
+      type: 'github',
+      url: 'https://github.com/allanpk716/work-skills',
+      branch: 'main'
+    };
+
+    writeClaudeConfig(config);
+
+    return {
+      success: true,
+      path: getConfigPath()
+    };
+  } catch (error) {
+    return {
+      success: false,
+      path: getConfigPath(),
+      error: error.message
+    };
+  }
+}
+
+module.exports = {
+  getConfigPath,
+  readClaudeConfig,
+  writeClaudeConfig,
+  registerMarketplaceSource
+};

package/src/marketplace/index.js

@@ -0,0 +1,157 @@
+'use strict';
+
+const chalk = require('chalk');
+const { MultiSelect } = require('enquirer');
+const { t } = require('../i18n/index.js');
+const { registerMarketplaceSource } = require('./config-manager.js');
+const { fetchMarketplaceJson, parsePluginList } = require('./plugin-discovery.js');
+const { isPluginInstalled, installPlugins } = require('./plugin-installer.js');
+
+/**
+ * Display plugin list as a table
+ * @param {Array} plugins - List of plugins to display
+ */
+function displayPluginTable(plugins) {
+  console.log('\n' + chalk.bold(t('marketplace.available')));
+  console.log();
+
+  // Simple table format (no external table library)
+  const separator = chalk.gray('|----------------------|---------|------------------------------------------|');
+  const header = chalk.gray('| Name                 | Version | Description                              |');
+  console.log(separator);
+  console.log(header);
+  console.log(separator);
+
+  plugins.forEach(plugin => {
+    const name = plugin.name.padEnd(20).substring(0, 20);
+    const version = plugin.version.padEnd(7).substring(0, 7);
+    const desc = (plugin.description || '').padEnd(40).substring(0, 40);
+    const installed = isPluginInstalled(plugin.name);
+    const status = installed ? chalk.green(' [installed]') : '';
+    console.log(`| ${chalk.cyan(name)} | ${chalk.yellow(version)} | ${desc}|${status}`);
+  });
+
+  console.log(separator);
+}
+
+/**
+ * Display installation summary
+ * @param {Object} result - {installed, skipped, failed}
+ */
+function displayInstallSummary(result) {
+  console.log('\n' + chalk.bold(t('marketplace.summary')));
+  console.log(chalk.gray('─'.repeat(60)));
+
+  if (result.installed.length > 0) {
+    console.log(chalk.green('✓ ' + t('marketplace.summary_installed', { count: result.installed.length })));
+    result.installed.forEach(p => console.log(chalk.gray(`    - ${p.name} v${p.version}`)));
+  }
+
+  if (result.skipped.length > 0) {
+    console.log(chalk.yellow('⊘ ' + t('marketplace.summary_skipped', { count: result.skipped.length })));
+    result.skipped.forEach(p => console.log(chalk.gray(`    - ${p.name}`)));
+  }
+
+  if (result.failed.length > 0) {
+    console.log(chalk.red('✗ ' + t('marketplace.summary_failed', { count: result.failed.length })));
+    result.failed.forEach(p => console.log(chalk.gray(`    - ${p.name}: ${p.error}`)));
+  }
+
+  console.log(chalk.gray('─'.repeat(60)));
+
+  if (result.installed.length > 0) {
+    console.log(chalk.green('\n' + t('marketplace.complete')));
+  }
+}
+
+/**
+ * Main marketplace integration function
+ * @returns {Promise<{success: boolean, installed: number, skipped: number, failed: number}>}
+ */
+async function runMarketplaceIntegration() {
+  console.log(chalk.bold.blue('\n=== ' + t('marketplace.title') + ' ===\n'));
+
+  try {
+    // Step 1: Register marketplace source
+    console.log(chalk.gray(t('marketplace.registering')));
+    const registerResult = registerMarketplaceSource();
+
+    if (!registerResult.success) {
+      console.log(chalk.red('✗ Failed to register marketplace source'));
+      return { success: false, installed: 0, skipped: 0, failed: 0, error: registerResult.error };
+    }
+
+    console.log(chalk.green('✓ ' + t('marketplace.registered')));
+
+    // Step 2: Fetch plugin list
+    console.log(chalk.gray('\n' + t('marketplace.fetching')));
+    const marketplaceData = await fetchMarketplaceJson();
+    const plugins = parsePluginList(marketplaceData);
+
+    if (plugins.length === 0) {
+      console.log(chalk.yellow('No plugins available.'));
+      return { success: true, installed: 0, skipped: 0, failed: 0 };
+    }
+
+    // Step 3: Display plugins and prompt for selection
+    displayPluginTable(plugins);
+
+    const multiselect = new MultiSelect({
+      name: 'plugins',
+      message: t('marketplace.select_plugins'),
+      choices: plugins.map(p => ({
+        name: p.name,
+        message: `${p.name} (${p.version}) - ${(p.description || '').substring(0, 40)}...`,
+        disabled: isPluginInstalled(p.name)
+      })),
+      initial: []
+    });
+
+    const selectedNames = await multiselect.run();
+
+    if (selectedNames.length === 0) {
+      console.log(chalk.yellow('\n' + t('marketplace.none_selected')));
+      const alreadyInstalledCount = plugins.filter(p => isPluginInstalled(p.name)).length;
+      return { success: true, installed: 0, skipped: alreadyInstalledCount, failed: 0 };
+    }
+
+    // Step 4: Install selected plugins
+    const selectedPlugins = plugins.filter(p => selectedNames.includes(p.name));
+
+    const result = await installPlugins(selectedPlugins, {
+      onProgress: (plugin, status) => {
+        if (status === 'installing') {
+          console.log(chalk.gray(`  ${t('marketplace.installing', { name: plugin.name })}`));
+        } else if (status === 'installed') {
+          console.log(chalk.green(`  ✓ ${t('marketplace.install_success', { name: plugin.name })}`));
+        }
+      }
+    });
+
+    // Step 5: Display summary
+    displayInstallSummary(result);
+
+    return {
+      success: result.failed.length === 0,
+      installed: result.installed.length,
+      skipped: result.skipped.length,
+      failed: result.failed.length
+    };
+
+  } catch (error) {
+    // Handle specific errors
+    if (error.message.includes('Network') || error.message.includes('timeout')) {
+      console.log(chalk.red('\n✗ ' + t('marketplace.error.network')));
+    } else {
+      console.log(chalk.red('\n✗ ' + t('marketplace.error.unknown')));
+      console.log(chalk.gray('  ' + error.message));
+    }
+    return { success: false, installed: 0, skipped: 0, failed: 0, error: error.message };
+  }
+}
+
+module.exports = {
+  runMarketplaceIntegration,
+  displayPluginTable,
+  displayInstallSummary
+};

package/src/marketplace/plugin-discovery.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const https = require('https');
+
+/**
+ * GitHub raw content URL for marketplace.json
+ */
+const MARKETPLACE_URL = 'https://raw.githubusercontent.com/allanpk716/work-skills/main/.claude-plugin/marketplace.json';
+
+/**
+ * Fetch marketplace.json from GitHub
+ * @param {number} timeout - Request timeout in milliseconds (default: 10000)
+ * @returns {Promise<Object>} Parsed marketplace.json object
+ */
+function fetchMarketplaceJson(timeout = 10000) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(MARKETPLACE_URL, { timeout }, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          resolve(parsed);
+        } catch (err) {
+          reject(new Error('Failed to parse marketplace.json: ' + err.message));
+        }
+      });
+    });
+
+    req.on('error', (err) => {
+      reject(new Error('Network error: ' + err.message));
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Request timeout'));
+    });
+  });
+}
+
+/**
+ * Parse plugin list from marketplace data
+ * @param {Object} marketplaceData - Raw marketplace.json data
+ * @returns {Array<{name, description, version, source, category}>}
+ */
+function parsePluginList(marketplaceData) {
+  if (!marketplaceData.plugins || !Array.isArray(marketplaceData.plugins)) {
+    return [];
+  }
+
+  return marketplaceData.plugins.map(p => ({
+    name: p.name,
+    description: p.description || '',
+    version: p.version || '0.0.0',
+    source: p.source || '',
+    category: p.category || 'general'
+  }));
+}
+
+module.exports = {
+  MARKETPLACE_URL,
+  fetchMarketplaceJson,
+  parsePluginList
+};

package/src/marketplace/plugin-installer.js

@@ -0,0 +1,144 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const execa = require('execa');
+
+/**
+ * GitHub repository URL for work-skills
+ */
+const REPO_URL = 'https://github.com/allanpk716/work-skills.git';
+
+/**
+ * Get Claude Code skills directory path
+ * @returns {string} Path to ~/.claude/skills
+ */
+function getSkillsDir() {
+  return path.join(os.homedir(), '.claude', 'skills');
+}
+
+/**
+ * Check if a plugin is already installed
+ * @param {string} pluginName - Name of the plugin
+ * @returns {boolean} True if SKILL.md exists in plugin directory
+ */
+function isPluginInstalled(pluginName) {
+  const skillPath = path.join(getSkillsDir(), pluginName, 'SKILL.md');
+  return fs.existsSync(skillPath);
+}
+
+/**
+ * Install a single plugin
+ * @param {Object} plugin - Plugin object {name, version, source}
+ * @param {Object} options - Options {tempDir, onProgress}
+ * @returns {Promise<{success: boolean, path?: string, error?: string}>}
+ */
+async function installPlugin(plugin, options = {}) {
+  let tempDir = null;
+
+  try {
+    // Create temporary directory for cloning
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'work-skills-'));
+
+    // Notify progress
+    if (options.onProgress) {
+      options.onProgress(plugin, 'cloning');
+    }
+
+    // Clone repository with depth 1 (shallow clone)
+    await execa('git', ['clone', '--depth', '1', REPO_URL, tempDir]);
+
+    if (options.onProgress) {
+      options.onProgress(plugin, 'copying');
+    }
+
+    // Source and target paths
+    const sourcePath = path.join(tempDir, plugin.source.replace('./', ''));
+    const targetPath = path.join(getSkillsDir(), plugin.name);
+
+    // Ensure target directory exists
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+
+    // Copy plugin directory to skills directory
+    fs.cpSync(sourcePath, targetPath, { recursive: true });
+
+    // Clean up temp directory
+    fs.rmSync(tempDir, { recursive: true, force: true });
+
+    if (options.onProgress) {
+      options.onProgress(plugin, 'installed');
+    }
+
+    return {
+      success: true,
+      path: targetPath
+    };
+  } catch (error) {
+    // Clean up on error
+    if (tempDir && fs.existsSync(tempDir)) {
+      try {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      } catch (cleanupError) {
+        // Ignore cleanup errors
+      }
+    }
+
+    return {
+      success: false,
+      error: error.message || 'Unknown error'
+    };
+  }
+}
+
+/**
+ * Install multiple plugins
+ * @param {Array} plugins - Array of plugin objects {name, version, source}
+ * @param {Object} options - Options {onProgress}
+ * @returns {Promise<{installed: Array, skipped: Array, failed: Array}>}
+ */
+async function installPlugins(plugins, options = {}) {
+  const result = {
+    installed: [],
+    skipped: [],
+    failed: []
+  };
+
+  for (const plugin of plugins) {
+    // Check if already installed
+    if (isPluginInstalled(plugin.name)) {
+      result.skipped.push({
+        name: plugin.name,
+        version: plugin.version
+      });
+      continue;
+    }
+
+    // Install plugin
+    const installResult = await installPlugin(plugin, options);
+
+    if (installResult.success) {
+      result.installed.push({
+        name: plugin.name,
+        version: plugin.version,
+        path: installResult.path
+      });
+    } else {
+      result.failed.push({
+        name: plugin.name,
+        version: plugin.version,
+        error: installResult.error
+      });
+    }
+  }
+
+  return result;
+}
+
+module.exports = {
+  REPO_URL,
+  getSkillsDir,
+  isPluginInstalled,
+  installPlugin,
+  installPlugins
+};

package/src/platform.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const { t } = require('./i18n/index.js');
+
+/**
+ * Check if current platform is Windows
+ * @returns {boolean}
+ */
+function isWindows() {
+  return process.platform === 'win32';
+}
+
+/**
+ * Check platform and exit with error if not Windows
+ * This function checks if the current platform is Windows.
+ * If not Windows, it prints an error message and exits with code 1.
+ * If Windows, it returns true.
+ * @returns {boolean} - true if Windows, never returns false (exits instead)
+ */
+function checkPlatform() {
+  if (!isWindows()) {
+    console.error('');
+    console.error(t('error.windowsOnly'));
+    console.error(t('error.currentPlatform') + ': ' + process.platform);
+    console.error('');
+    process.exit(1);
+  }
+  return true;
+}
+
+module.exports = {
+  isWindows,
+  checkPlatform
+};

package/src/verification/formatter.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const chalk = require('chalk');
+
+/**
+ * Format verification results as a simple ASCII table
+ * @param {Array<{name: string, status: string, symbol: string, details: string}>} results
+ * @returns {string} Formatted table string
+ */
+function formatVerificationTable(results) {
+  const separator = chalk.gray('|---------------------------|------------|--------------------------------------------------|');
+  const header = chalk.gray('| Check                     | Status     | Details                                          |');
+
+  const lines = [separator, header, separator];
+
+  results.forEach(result => {
+    let statusIcon;
+    if (result.status === 'PASS') {
+      statusIcon = chalk.green('✓ PASS');
+    } else if (result.status === 'FAIL') {
+      statusIcon = chalk.red('✗ FAIL');
+    } else {
+      statusIcon = chalk.gray('⊘ SKIP');
+    }
+
+    const name = result.name.padEnd(25).substring(0, 25);
+    const status = statusIcon.padEnd(10);
+    const details = (result.details || '').padEnd(48).substring(0, 48);
+
+    lines.push(`| ${name} | ${status} | ${details}|`);
+  });
+
+  lines.push(separator);
+
+  return lines.join('\n');
+}
+
+/**
+ * Calculate verification summary statistics
+ * @param {Array<{status: string}>} results
+ * @returns {{passed: number, total: number}}
+ */
+function calculateSummary(results) {
+  const passed = results.filter(r => r.status === 'PASS').length;
+  const total = results.length;
+
+  return { passed, total };
+}
+
+/**
+ * Display common solutions for failed checks
+ */
+function displayCommonSolutions() {
+  console.log(chalk.yellow('\nCommon solutions:'));
+  console.log('  - Install missing Python libraries: pip install requests');
+  console.log('  - Set environment variables: PUSHOVER_TOKEN, PUSHOVER_USER');
+  console.log('  - Check PowerShell execution policy');
+}
+
+module.exports = {
+  formatVerificationTable,
+  calculateSummary,
+  displayCommonSolutions
+};

package/src/verification/index.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const chalk = require('chalk');
+const { t } = require('../i18n/index.js');
+const { runPythonVerification } = require('./runner.js');
+const { parseVerificationOutput } = require('./parser.js');
+const { formatVerificationTable, calculateSummary, displayCommonSolutions } = require('./formatter.js');
+
+/**
+ * Run installation verification and display results
+ * @returns {Promise<{success: boolean, passed: number, total: number}>}
+ */
+async function runVerification() {
+  // Display verification title
+  console.log(chalk.bold.blue('\n=== ' + t('verification.title') + ' ===\n'));
+
+  // Step 1: Execute Python verification script
+  const execResult = await runPythonVerification();
+
+  // Step 2: Handle execution errors
+  if (!execResult.success) {
+    if (execResult.error === 'python_not_found') {
+      console.error(chalk.red(t('verification.error.pythonNotFound')));
+      console.error(chalk.gray('Install Python 3.8+ from https://www.python.org/'));
+      return { success: false, passed: 0, total: 0 };
+    }
+
+    if (execResult.error === 'script_not_found') {
+      console.error(chalk.red(t('verification.error.scriptNotFound')));
+      return { success: false, passed: 0, total: 0 };
+    }
+
+    if (execResult.error === 'timeout') {
+      console.error(chalk.red(t('verification.error.timeout')));
+      return { success: false, passed: 0, total: 0 };
+    }
+
+    // Generic execution failure
+    console.error(chalk.red(t('verification.error.executionFailed')));
+    if (execResult.stderr) {
+      console.error(chalk.gray(execResult.stderr));
+    }
+    return { success: false, passed: 0, total: 0 };
+  }
+
+  // Step 3: Parse output
+  const results = parseVerificationOutput(execResult.stdout);
+
+  // Step 4: Format and display table
+  const table = formatVerificationTable(results);
+  console.log(table);
+
+  // Step 5: Calculate and display summary
+  const { passed, total } = calculateSummary(results);
+  console.log('\n' + t('verification.summary', { passed, total }));
+
+  // Step 6: Display common solutions if any checks failed
+  if (passed < total) {
+    displayCommonSolutions();
+  }
+
+  // Step 7: Display rerun command
+  console.log(chalk.gray('\n' + t('verification.rerunCommand')));
+
+  // Step 8: Display next steps guidance
+  console.log(chalk.cyan('\n=== ' + t('verification.nextSteps') + ' ==='));
+  console.log(chalk.white(t('verification.nextStep1')));
+  console.log(chalk.white(t('verification.nextStep2')));
+  console.log(chalk.white(t('verification.nextStep3')));
+  console.log(chalk.gray(t('verification.nextStep4')));
+
+  // Step 9: Return result (success requires at least 5/7 checks to pass)
+  const success = passed >= 5;
+  return { success, passed, total };
+}
+
+module.exports = {
+  runVerification
+};

package/src/verification/parser.js

@@ -0,0 +1,53 @@
+'use strict';
+
+/**
+ * Parse Python verification script output into structured results
+ * @param {string} stdout - Raw output from Python script
+ * @returns {Array<{name: string, status: string, symbol: string, details: string}>}
+ */
+function parseVerificationOutput(stdout) {
+  if (!stdout || stdout.trim() === '') {
+    return [];
+  }
+
+  const lines = stdout.split('\n');
+  const results = [];
+
+  // Pattern: "  [OK] Python version: PASS"
+  // Pattern: "  [X] Environment Variables: FAIL"
+  // Pattern: "  [OK] Pushover API: SKIP"
+  const pattern = /^\s*\[(OK|X)\]\s*(.+?):\s*(PASS|FAIL|SKIP)/;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const match = line.match(pattern);
+
+    if (match) {
+      const [, symbol, name, status] = match;
+
+      // Check if next line is a detail line (indented, not a result line)
+      let details = '';
+      if (i + 1 < lines.length) {
+        const nextLine = lines[i + 1].trim();
+        // Detail lines start with spaces but don't match the result pattern
+        if (nextLine && !nextLine.match(/^\s*\[(OK|X)\]/)) {
+          details = nextLine;
+          i++; // Skip the detail line in next iteration
+        }
+      }
+
+      results.push({
+        name: name.trim(),
+        status,  // 'PASS' | 'FAIL' | 'SKIP'
+        symbol,  // 'OK' | 'X'
+        details
+      });
+    }
+  }
+
+  return results;
+}
+
+module.exports = {
+  parseVerificationOutput
+};