cskit-cli 1.0.21 → 1.0.23

package/src/commands/python.js

@@ -0,0 +1,170 @@
+'use strict';
+
+/**
+ * Python Check Command
+ *
+ * Diagnose Python installation and provide installation guidance.
+ */
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const {
+  checkAndReport,
+  detectPython,
+  detectPip,
+  getInstallInstructions,
+  getPlatform,
+  canAutoInstall,
+  installPython,
+  MIN_PYTHON_VERSION
+} = require('../lib/python-check');
+
+async function pythonCommand(options) {
+  const python = detectPython();
+
+  if (options.json) {
+    // JSON output for scripting
+    const pip = python.found ? detectPip(python.command) : { found: false };
+    const autoInstall = canAutoInstall();
+    console.log(JSON.stringify({
+      platform: getPlatform(),
+      python: {
+        found: python.found,
+        command: python.command,
+        version: python.version,
+        path: python.path,
+        meetsMinimum: python.meetsMinimum,
+        minRequired: MIN_PYTHON_VERSION
+      },
+      pip: {
+        found: pip.found,
+        version: pip.version
+      },
+      autoInstall: {
+        available: autoInstall.canInstall,
+        manager: autoInstall.manager,
+        needsSudo: autoInstall.needsSudo
+      }
+    }, null, 2));
+    return;
+  }
+
+  // Auto-install Python
+  if (options.auto) {
+    if (python.found && python.meetsMinimum) {
+      console.log(chalk.green(`\n✓ Python ${python.version} already installed.\n`));
+      return;
+    }
+
+    const autoInfo = canAutoInstall();
+    if (!autoInfo.canInstall) {
+      console.log(chalk.red('\n✗ No supported package manager found.'));
+      console.log(chalk.dim('  Please install Python manually.\n'));
+      console.log(chalk.dim('  Run `cskit python --install` for instructions.\n'));
+      process.exit(1);
+    }
+
+    console.log('');
+    console.log(chalk.cyan(`Auto-install via ${autoInfo.manager}`));
+    if (autoInfo.needsSudo) {
+      console.log(chalk.yellow('(requires sudo password)'));
+    }
+    console.log(chalk.dim(`Command: ${autoInfo.command}`));
+    console.log('');
+
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: 'Proceed with installation?',
+      default: true
+    }]);
+
+    if (!confirm) {
+      console.log(chalk.dim('\nInstallation cancelled.\n'));
+      return;
+    }
+
+    console.log('');
+    const result = await installPython((msg) => {
+      console.log(chalk.dim(`  ${msg}`));
+    });
+
+    if (result.success) {
+      console.log('');
+      console.log(chalk.green(`✓ Python ${result.version} installed successfully!`));
+      console.log(chalk.dim('  You may need to restart your terminal for PATH changes.'));
+      console.log('');
+    } else {
+      console.log('');
+      console.log(chalk.red(`✗ ${result.error}`));
+      console.log('');
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (options.install) {
+    // Show installation instructions
+    const instructions = getInstallInstructions();
+    const autoInfo = canAutoInstall();
+
+    console.log('');
+    console.log(chalk.bold(`Python Installation Guide (${getPlatform()})`));
+    console.log(chalk.dim('─'.repeat(50)));
+
+    if (autoInfo.canInstall) {
+      console.log('');
+      console.log(chalk.green(`Auto-install available: cskit python --auto`));
+      console.log(chalk.dim(`  Uses: ${autoInfo.manager}`));
+    }
+
+    console.log('');
+    console.log(chalk.cyan(`Manual: ${instructions.method}`));
+    console.log('');
+
+    for (const cmd of instructions.commands) {
+      if (cmd.startsWith('#')) {
+        console.log(chalk.dim(cmd));
+      } else if (cmd === '') {
+        console.log('');
+      } else {
+        console.log(chalk.green(`  ${cmd}`));
+      }
+    }
+
+    if (instructions.notes.length > 0) {
+      console.log('');
+      console.log(chalk.bold('Notes:'));
+      for (const note of instructions.notes) {
+        console.log(chalk.dim(`  • ${note}`));
+      }
+    }
+
+    console.log('');
+    return;
+  }
+
+  // Default: check and report
+  const result = checkAndReport();
+
+  if (result.ok) {
+    console.log('');
+    console.log(chalk.green('✓ Python environment is ready for CSK.'));
+    console.log('');
+  } else if (!python.found) {
+    const autoInfo = canAutoInstall();
+    console.log('');
+    if (autoInfo.canInstall) {
+      console.log(chalk.cyan(`Auto-install: cskit python --auto (via ${autoInfo.manager})`));
+    }
+    console.log(chalk.dim('Manual guide: cskit python --install'));
+    console.log('');
+    process.exit(1);
+  } else {
+    console.log('');
+    console.log(chalk.yellow('Python upgrade recommended.'));
+    console.log('');
+  }
+}
+
+module.exports = pythonCommand;

package/src/index.js

@@ -16,6 +16,7 @@ const initCommand = require('./commands/init');
 const authCommand = require('./commands/auth');
 const statusCommand = require('./commands/status');
 const updateCommand = require('./commands/update');
+const pythonCommand = require('./commands/python');
 
 const program = new Command();
 
@@ -67,6 +68,15 @@ program
   .description('Update CSK CLI to latest version')
   .action(updateCommand);
 
+// Python command - check Python environment
+program
+  .command('python')
+  .description('Check Python installation status')
+  .option('--install', 'Show installation instructions')
+  .option('--auto', 'Auto-install Python via package manager')
+  .option('--json', 'Output as JSON for scripting')
+  .action(pythonCommand);
+
 // Parse arguments
 program.parse(process.argv);
 

package/src/lib/github.js

@@ -266,6 +266,100 @@ async function getRepoTreeFromRef(token, ref) {
   return data.tree || [];
 }
 
+/**
+ * Download repository as zip archive from specific ref
+ * @param {string} token - GitHub PAT
+ * @param {string} ref - Tag or branch name
+ * @returns {Promise<Buffer>} - Zip file buffer
+ */
+async function downloadZipFromRef(token, ref) {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: 'api.github.com',
+      path: `/repos/${GITHUB_OWNER}/${GITHUB_REPO}/zipball/${ref}`,
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'Accept': 'application/vnd.github+json',
+        'User-Agent': 'csk-cli',
+        'X-GitHub-Api-Version': '2022-11-28'
+      }
+    };
+
+    const req = https.request(options, (res) => {
+      // GitHub returns 302 redirect to the actual zip URL
+      if (res.statusCode === 302 || res.statusCode === 301) {
+        const redirectUrl = new URL(res.headers.location);
+
+        // Choose http or https based on protocol
+        const protocol = redirectUrl.protocol === 'https:' ? https : require('http');
+
+        const redirectOptions = {
+          hostname: redirectUrl.hostname,
+          path: redirectUrl.pathname + redirectUrl.search,
+          method: 'GET',
+          headers: {
+            'User-Agent': 'csk-cli'
+          }
+        };
+
+        const redirectReq = protocol.request(redirectOptions, (redirectRes) => {
+          // Handle another redirect (GitHub sometimes does this)
+          if (redirectRes.statusCode === 302 || redirectRes.statusCode === 301) {
+            const secondUrl = new URL(redirectRes.headers.location);
+            const secondProtocol = secondUrl.protocol === 'https:' ? https : require('http');
+
+            const secondOptions = {
+              hostname: secondUrl.hostname,
+              path: secondUrl.pathname + secondUrl.search,
+              method: 'GET',
+              headers: { 'User-Agent': 'csk-cli' }
+            };
+
+            const secondReq = secondProtocol.request(secondOptions, (secondRes) => {
+              if (secondRes.statusCode !== 200) {
+                reject(new Error(`Failed to download zip: ${secondRes.statusCode}`));
+                return;
+              }
+              const chunks = [];
+              secondRes.on('data', chunk => chunks.push(chunk));
+              secondRes.on('end', () => resolve(Buffer.concat(chunks)));
+            });
+            secondReq.on('error', reject);
+            secondReq.end();
+            return;
+          }
+
+          if (redirectRes.statusCode !== 200) {
+            reject(new Error(`Failed to download zip: ${redirectRes.statusCode}`));
+            return;
+          }
+
+          const chunks = [];
+          redirectRes.on('data', chunk => chunks.push(chunk));
+          redirectRes.on('end', () => resolve(Buffer.concat(chunks)));
+        });
+
+        redirectReq.on('error', reject);
+        redirectReq.end();
+        return;
+      }
+
+      if (res.statusCode !== 200) {
+        reject(new Error(`Failed to download zip: ${res.statusCode}`));
+        return;
+      }
+
+      const chunks = [];
+      res.on('data', chunk => chunks.push(chunk));
+      res.on('end', () => resolve(Buffer.concat(chunks)));
+    });
+
+    req.on('error', reject);
+    req.end();
+  });
+}
+
 module.exports = {
   verifyAccess,
   getRepoTree,
@@ -273,6 +367,7 @@ module.exports = {
   getFileContent,
   downloadFile,
   downloadFileFromRef,
+  downloadZipFromRef,
   getLatestRelease,
   getAllReleases
 };

package/src/lib/python-check.js

@@ -0,0 +1,402 @@
+'use strict';
+
+/**
+ * Python Detection and Installation Helper
+ *
+ * Detects Python availability, version, and provides
+ * platform-specific installation guidance.
+ */
+
+const { execSync, spawnSync } = require('child_process');
+const os = require('os');
+const chalk = require('chalk');
+
+// Minimum Python version required
+const MIN_PYTHON_VERSION = '3.8';
+
+/**
+ * Detect current platform
+ * @returns {'windows'|'macos'|'linux'}
+ */
+function getPlatform() {
+  const platform = os.platform();
+  if (platform === 'win32') return 'windows';
+  if (platform === 'darwin') return 'macos';
+  return 'linux';
+}
+
+/**
+ * Try to find Python executable
+ * @returns {{found: boolean, command: string|null, version: string|null, path: string|null}}
+ */
+function detectPython() {
+  const platform = getPlatform();
+
+  // Commands to try in order of preference
+  const commands = platform === 'windows'
+    ? ['python', 'python3', 'py -3', 'py']
+    : ['python3', 'python'];
+
+  for (const cmd of commands) {
+    try {
+      // Get version
+      const versionResult = spawnSync(
+        cmd.split(' ')[0],
+        [...cmd.split(' ').slice(1), '--version'],
+        { encoding: 'utf-8', shell: true, timeout: 5000 }
+      );
+
+      if (versionResult.status === 0) {
+        const output = (versionResult.stdout || versionResult.stderr || '').trim();
+        const match = output.match(/Python (\d+\.\d+\.\d+)/i);
+
+        if (match) {
+          const version = match[1];
+
+          // Get path
+          let pythonPath = null;
+          try {
+            const pathCmd = platform === 'windows'
+              ? `${cmd} -c "import sys; print(sys.executable)"`
+              : `${cmd} -c 'import sys; print(sys.executable)'`;
+
+            pythonPath = execSync(pathCmd, { encoding: 'utf-8', timeout: 5000 }).trim();
+          } catch (e) {
+            // Ignore path detection errors
+          }
+
+          return {
+            found: true,
+            command: cmd,
+            version,
+            path: pythonPath,
+            meetsMinimum: compareVersions(version, MIN_PYTHON_VERSION) >= 0
+          };
+        }
+      }
+    } catch (e) {
+      // Continue to next command
+    }
+  }
+
+  return { found: false, command: null, version: null, path: null, meetsMinimum: false };
+}
+
+/**
+ * Compare semantic versions
+ * @param {string} v1
+ * @param {string} v2
+ * @returns {number} -1 if v1 < v2, 0 if equal, 1 if v1 > v2
+ */
+function compareVersions(v1, v2) {
+  const parts1 = v1.split('.').map(Number);
+  const parts2 = v2.split('.').map(Number);
+
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const p1 = parts1[i] || 0;
+    const p2 = parts2[i] || 0;
+    if (p1 < p2) return -1;
+    if (p1 > p2) return 1;
+  }
+  return 0;
+}
+
+/**
+ * Check if pip is available
+ * @param {string} pythonCmd - Python command to use
+ * @returns {{found: boolean, version: string|null}}
+ */
+function detectPip(pythonCmd) {
+  try {
+    const result = spawnSync(
+      pythonCmd.split(' ')[0],
+      [...pythonCmd.split(' ').slice(1), '-m', 'pip', '--version'],
+      { encoding: 'utf-8', shell: true, timeout: 5000 }
+    );
+
+    if (result.status === 0) {
+      const match = (result.stdout || '').match(/pip (\d+\.\d+)/);
+      return { found: true, version: match ? match[1] : 'unknown' };
+    }
+  } catch (e) {
+    // Ignore
+  }
+
+  return { found: false, version: null };
+}
+
+/**
+ * Get installation instructions for current platform
+ * @returns {{method: string, commands: string[], notes: string[]}}
+ */
+function getInstallInstructions() {
+  const platform = getPlatform();
+
+  switch (platform) {
+    case 'windows':
+      return {
+        method: 'Microsoft Store or python.org',
+        commands: [
+          '# Option 1: Microsoft Store (recommended)',
+          'winget install Python.Python.3.12',
+          '',
+          '# Option 2: Download from python.org',
+          '# https://www.python.org/downloads/windows/',
+          '',
+          '# After install, restart terminal and run:',
+          'python --version'
+        ],
+        notes: [
+          'Check "Add Python to PATH" during installation',
+          'Restart terminal after installation'
+        ]
+      };
+
+    case 'macos':
+      return {
+        method: 'Homebrew or python.org',
+        commands: [
+          '# Option 1: Homebrew (recommended)',
+          'brew install python@3.12',
+          '',
+          '# Option 2: Download from python.org',
+          '# https://www.python.org/downloads/macos/',
+          '',
+          '# Option 3: Xcode Command Line Tools',
+          'xcode-select --install'
+        ],
+        notes: [
+          'Homebrew: https://brew.sh if not installed',
+          'After install: python3 --version'
+        ]
+      };
+
+    case 'linux':
+      return {
+        method: 'Package manager',
+        commands: [
+          '# Debian/Ubuntu:',
+          'sudo apt update && sudo apt install python3 python3-pip',
+          '',
+          '# Fedora:',
+          'sudo dnf install python3 python3-pip',
+          '',
+          '# Arch:',
+          'sudo pacman -S python python-pip'
+        ],
+        notes: [
+          'Most Linux distros have Python pre-installed',
+          'Verify with: python3 --version'
+        ]
+      };
+  }
+}
+
+/**
+ * Display Python status and instructions
+ * @returns {{ok: boolean, pythonCmd: string|null}}
+ */
+function checkAndReport() {
+  const python = detectPython();
+  const platform = getPlatform();
+
+  console.log('');
+  console.log(chalk.bold('Python Environment Check'));
+  console.log(chalk.dim('─'.repeat(40)));
+  console.log(`Platform: ${chalk.cyan(platform)}`);
+
+  if (python.found) {
+    const versionColor = python.meetsMinimum ? chalk.green : chalk.yellow;
+    console.log(`Python:   ${versionColor(python.version)} (${python.command})`);
+
+    if (python.path) {
+      console.log(`Path:     ${chalk.dim(python.path)}`);
+    }
+
+    if (!python.meetsMinimum) {
+      console.log('');
+      console.log(chalk.yellow(`⚠ Python ${MIN_PYTHON_VERSION}+ required, found ${python.version}`));
+      console.log(chalk.dim('  Some features may not work correctly'));
+    }
+
+    // Check pip
+    const pip = detectPip(python.command);
+    if (pip.found) {
+      console.log(`pip:      ${chalk.green(pip.version)}`);
+    } else {
+      console.log(`pip:      ${chalk.yellow('not found')}`);
+      console.log(chalk.dim(`  Install: ${python.command} -m ensurepip --upgrade`));
+    }
+
+    console.log(chalk.dim('─'.repeat(40)));
+    return { ok: python.meetsMinimum, pythonCmd: python.command };
+  }
+
+  // Python not found
+  console.log(`Python:   ${chalk.red('not found')}`);
+  console.log('');
+  console.log(chalk.yellow('Python is required for advanced CSK features:'));
+  console.log(chalk.dim('  - Data fetching and analysis'));
+  console.log(chalk.dim('  - Chart generation'));
+  console.log(chalk.dim('  - MCP server tools'));
+  console.log('');
+
+  const instructions = getInstallInstructions();
+  console.log(chalk.bold(`Install via ${instructions.method}:`));
+  console.log('');
+
+  for (const cmd of instructions.commands) {
+    if (cmd.startsWith('#')) {
+      console.log(chalk.dim(cmd));
+    } else if (cmd === '') {
+      console.log('');
+    } else {
+      console.log(chalk.cyan(`  ${cmd}`));
+    }
+  }
+
+  if (instructions.notes.length > 0) {
+    console.log('');
+    console.log(chalk.dim('Notes:'));
+    for (const note of instructions.notes) {
+      console.log(chalk.dim(`  • ${note}`));
+    }
+  }
+
+  console.log(chalk.dim('─'.repeat(40)));
+  return { ok: false, pythonCmd: null };
+}
+
+/**
+ * Quick check - returns Python command or null
+ * @returns {string|null}
+ */
+function quickCheck() {
+  const python = detectPython();
+  return python.found && python.meetsMinimum ? python.command : null;
+}
+
+/**
+ * Check if a package manager is available
+ * @returns {{available: boolean, manager: string|null, installCmd: string|null}}
+ */
+function detectPackageManager() {
+  const platform = getPlatform();
+
+  const managers = {
+    windows: [
+      { name: 'winget', check: 'winget --version', install: 'winget install Python.Python.3.12 --accept-package-agreements --accept-source-agreements' },
+      { name: 'choco', check: 'choco --version', install: 'choco install python3 -y' },
+      { name: 'scoop', check: 'scoop --version', install: 'scoop install python' }
+    ],
+    macos: [
+      { name: 'brew', check: 'brew --version', install: 'brew install python@3.12' }
+    ],
+    linux: [
+      { name: 'apt', check: 'apt --version', install: 'sudo apt update && sudo apt install -y python3 python3-pip python3-venv' },
+      { name: 'dnf', check: 'dnf --version', install: 'sudo dnf install -y python3 python3-pip' },
+      { name: 'pacman', check: 'pacman --version', install: 'sudo pacman -S --noconfirm python python-pip' },
+      { name: 'apk', check: 'apk --version', install: 'apk add python3 py3-pip' }
+    ]
+  };
+
+  const platformManagers = managers[platform] || [];
+
+  for (const mgr of platformManagers) {
+    try {
+      const result = spawnSync(mgr.check.split(' ')[0], mgr.check.split(' ').slice(1), {
+        encoding: 'utf-8',
+        shell: true,
+        timeout: 5000,
+        stdio: 'pipe'
+      });
+
+      if (result.status === 0) {
+        return {
+          available: true,
+          manager: mgr.name,
+          installCmd: mgr.install
+        };
+      }
+    } catch (e) {
+      // Continue to next manager
+    }
+  }
+
+  return { available: false, manager: null, installCmd: null };
+}
+
+/**
+ * Attempt to install Python using detected package manager
+ * @param {function} onProgress - Callback for progress updates
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+async function installPython(onProgress = console.log) {
+  const pkgMgr = detectPackageManager();
+
+  if (!pkgMgr.available) {
+    return {
+      success: false,
+      error: 'No supported package manager found. Please install Python manually.'
+    };
+  }
+
+  onProgress(`Installing Python via ${pkgMgr.manager}...`);
+  onProgress(`Command: ${pkgMgr.installCmd}`);
+
+  try {
+    // Execute install command
+    execSync(pkgMgr.installCmd, {
+      stdio: 'inherit',  // Show output to user
+      shell: true,
+      timeout: 300000  // 5 minute timeout
+    });
+
+    // Verify installation
+    const python = detectPython();
+    if (python.found) {
+      onProgress(`Python ${python.version} installed successfully!`);
+      return { success: true, version: python.version, command: python.command };
+    } else {
+      return {
+        success: false,
+        error: 'Installation completed but Python not detected. You may need to restart your terminal.'
+      };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: `Installation failed: ${error.message}`
+    };
+  }
+}
+
+/**
+ * Check if auto-install is possible
+ * @returns {{canInstall: boolean, manager: string|null, command: string|null, needsSudo: boolean}}
+ */
+function canAutoInstall() {
+  const pkgMgr = detectPackageManager();
+  const platform = getPlatform();
+
+  return {
+    canInstall: pkgMgr.available,
+    manager: pkgMgr.manager,
+    command: pkgMgr.installCmd,
+    needsSudo: platform === 'linux' && pkgMgr.installCmd?.includes('sudo')
+  };
+}
+
+module.exports = {
+  getPlatform,
+  detectPython,
+  detectPip,
+  compareVersions,
+  getInstallInstructions,
+  checkAndReport,
+  quickCheck,
+  detectPackageManager,
+  installPython,
+  canAutoInstall,
+  MIN_PYTHON_VERSION
+};