cskit-cli 1.0.20 → 1.0.22

package/src/commands/init.js

@@ -1,299 +1,418 @@
 'use strict';
 
 /**
- * Init Command
+ * Init Command - Improved Version
  *
- * Downloads CSK from private GitHub repository.
- * Features: version selection, progress bar, Python setup.
+ * Features:
+ * - Download zip instead of individual files
+ * - Timeline progress display (◇ pending → ◆ done)
+ * - Scan and show files to be overwritten
+ * - User confirmation before changes
+ * - Optional advanced packages installation
+ * - Platform-specific handling
  */
 
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 const chalk = require('chalk');
-const ora = require('ora');
-const crypto = require('crypto');
 const inquirer = require('inquirer');
-const { execSync, spawn } = require('child_process');
+const crypto = require('crypto');
+const { execSync, spawnSync } = require('child_process');
 const { getToken } = require('../lib/keychain');
 const {
   verifyAccess,
-  getRepoTreeFromRef,
-  downloadFileFromRef,
   getAllReleases,
-  getLatestRelease
+  getLatestRelease,
+  downloadZipFromRef
 } = require('../lib/github');
 const {
   isProtected,
   shouldExclude,
-  determineMergeAction,
   loadManifest,
   saveManifest,
   ensureDir
 } = require('../lib/merge');
+const {
+  detectPython,
+  checkAndReport: checkPythonEnv,
+  getInstallInstructions,
+  canAutoInstall,
+  installPython
+} = require('../lib/python-check');
+
+// =============================================================================
+// Timeline Display
+// =============================================================================
+
+const SYMBOLS = {
+  pending: chalk.dim('◇'),
+  active: chalk.cyan('◈'),
+  done: chalk.green('◆'),
+  error: chalk.red('◆'),
+  skip: chalk.yellow('◇'),
+  file: chalk.dim('│  '),
+  fileNew: chalk.green('│  + '),
+  fileUpdate: chalk.blue('│  ~ '),
+  fileSkip: chalk.yellow('│  ! '),
+  fileDel: chalk.red('│  - '),
+  branch: chalk.dim('├──'),
+  branchLast: chalk.dim('└──'),
+  indent: '   ',
+};
+
+class Timeline {
+  constructor() {
+    this.steps = [];
+    this.currentStep = -1;
+  }
+
+  addStep(name) {
+    this.steps.push({ name, status: 'pending', children: [] });
+  }
+
+  start(stepIndex) {
+    this.currentStep = stepIndex;
+    this.steps[stepIndex].status = 'active';
+    this.render();
+  }
+
+  complete(stepIndex, message = null) {
+    this.steps[stepIndex].status = 'done';
+    if (message) this.steps[stepIndex].message = message;
+    this.render();
+  }
+
+  error(stepIndex, message) {
+    this.steps[stepIndex].status = 'error';
+    this.steps[stepIndex].message = message;
+    this.render();
+  }
+
+  skip(stepIndex, message) {
+    this.steps[stepIndex].status = 'skip';
+    this.steps[stepIndex].message = message;
+    this.render();
+  }
+
+  addChild(stepIndex, text, type = 'info') {
+    this.steps[stepIndex].children.push({ text, type });
+  }
+
+  render() {
+    // Clear and redraw (simple version)
+    console.log('');
+    for (let i = 0; i < this.steps.length; i++) {
+      const step = this.steps[i];
+      const symbol = SYMBOLS[step.status];
+      const num = chalk.dim(`${i + 1}.`);
+      const name = step.status === 'active' ? chalk.cyan(step.name) : step.name;
+      const msg = step.message ? chalk.dim(` (${step.message})`) : '';
+
+      console.log(`  ${symbol} ${num} ${name}${msg}`);
+
+      // Show children (files, etc.)
+      for (let j = 0; j < step.children.length; j++) {
+        const child = step.children[j];
+        const isLast = j === step.children.length - 1;
+        const branch = isLast ? SYMBOLS.branchLast : SYMBOLS.branch;
+        const prefix = child.type === 'new' ? chalk.green('+') :
+                       child.type === 'update' ? chalk.blue('~') :
+                       child.type === 'skip' ? chalk.yellow('!') :
+                       child.type === 'delete' ? chalk.red('-') :
+                       chalk.dim('•');
+        console.log(`  ${SYMBOLS.indent}${branch} ${prefix} ${child.text}`);
+      }
+    }
+    console.log('');
+  }
+}
+
+// =============================================================================
+// Utility Functions
+// =============================================================================
 
-/**
- * Format date for display
- */
 function formatDate(isoDate) {
   const d = new Date(isoDate);
   return d.toLocaleDateString('en-US', { year: 'numeric', month: 'short', day: 'numeric' });
 }
 
-/**
- * Create progress bar string
- */
-function progressBar(current, total, width = 30) {
-  const percent = Math.round((current / total) * 100);
-  const filled = Math.round((current / total) * width);
-  const empty = width - filled;
-  const bar = chalk.green('█'.repeat(filled)) + chalk.dim('░'.repeat(empty));
-  return `${bar} ${percent}%`;
+function getPlatform() {
+  const platform = os.platform();
+  if (platform === 'win32') return 'windows';
+  if (platform === 'darwin') return 'macos';
+  return 'linux';
 }
 
-/**
- * Setup Python virtual environment
- */
-async function setupPythonEnv(projectDir, spinner) {
-  const libPythonDir = path.join(projectDir, 'lib', 'python');
-  const requirementsFile = path.join(libPythonDir, 'requirements.txt');
+function remapPath(filePath) {
+  const mappings = [
+    { from: 'src/commands/', to: '.claude/commands/' },
+    { from: 'src/skills/', to: '.claude/skills/' },
+    { from: 'core/', to: '.claude/skills/csk/core/' },
+    { from: 'domains/', to: '.claude/skills/csk/domains/' },
+    { from: 'industries/', to: '.claude/skills/csk/industries/' }
+  ];
 
-  if (!fs.existsSync(requirementsFile)) {
-    return { success: true, skipped: true };
+  for (const { from, to } of mappings) {
+    if (filePath.startsWith(from)) {
+      return filePath.replace(from, to);
+    }
   }
+  return filePath;
+}
 
-  spinner.start('Setting up Python environment...');
-
-  const venvPath = path.join(libPythonDir, '.venv');
+async function extractZip(zipPath, destDir) {
+  const platform = getPlatform();
 
   try {
-    // Check if Python 3 is available and get version
-    let pythonVersion;
-    try {
-      pythonVersion = execSync('python3 --version', { stdio: 'pipe' }).toString().trim();
-      spinner.text = `Found ${pythonVersion}`;
-    } catch {
-      spinner.warn('Python 3 not found, skipping venv setup');
-      return { success: true, skipped: true, reason: 'python3 not found' };
+    if (platform === 'windows') {
+      // Use PowerShell on Windows
+      execSync(`powershell -command "Expand-Archive -Path '${zipPath}' -DestinationPath '${destDir}' -Force"`, { stdio: 'pipe' });
+    } else {
+      // Use unzip on Unix/macOS
+      execSync(`unzip -o -q "${zipPath}" -d "${destDir}"`, { stdio: 'pipe' });
     }
+    return { success: true };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
 
-    // Check minimum version (3.9+)
-    const versionMatch = pythonVersion.match(/Python (\d+)\.(\d+)/);
-    if (versionMatch) {
-      const [, major, minor] = versionMatch.map(Number);
-      if (major < 3 || (major === 3 && minor < 9)) {
-        spinner.warn(`Python ${major}.${minor} found, requires 3.9+`);
-        return { success: true, skipped: true, reason: `Python ${major}.${minor} requires 3.9+` };
-      }
-    }
+function scanDirectory(dir, basePath = '') {
+  const files = [];
+  if (!fs.existsSync(dir)) return files;
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    const relativePath = path.join(basePath, entry.name);
 
-    // Create venv if not exists
-    if (!fs.existsSync(venvPath)) {
-      spinner.text = 'Creating virtual environment...';
-      execSync(`python3 -m venv "${venvPath}"`, { stdio: 'pipe', cwd: libPythonDir });
+    if (entry.isDirectory()) {
+      files.push(...scanDirectory(fullPath, relativePath));
+    } else {
+      files.push(relativePath);
     }
+  }
+  return files;
+}
 
-    // Parse requirements.txt (strip inline comments)
-    const pipPath = path.join(venvPath, 'bin', 'pip');
-    const requirements = fs.readFileSync(requirementsFile, 'utf8')
-      .split('\n')
-      .map(line => line.split('#')[0].trim()) // Remove inline comments
-      .filter(line => line); // Remove empty lines
+function compareFiles(sourceDir, targetDir, manifest) {
+  const sourceFiles = scanDirectory(sourceDir);
+  const changes = { new: [], update: [], skip: [], protected: [] };
 
-    if (requirements.length === 0) {
-      spinner.succeed('No packages to install');
-      return { success: true, version: pythonVersion };
-    }
+  for (const file of sourceFiles) {
+    if (shouldExclude(file)) continue;
 
-    // Upgrade pip first (silent)
-    spinner.text = 'Upgrading pip...';
-    try {
-      execSync(`"${pipPath}" install --upgrade pip -q`, { stdio: 'pipe', cwd: libPythonDir });
-    } catch { /* ignore pip upgrade errors */ }
+    const targetPath = remapPath(file);
+    const fullTargetPath = path.join(targetDir, targetPath);
 
-    // Check which packages need installation
-    spinner.text = 'Checking installed packages...';
-    let installedPkgs = [];
-    try {
-      const freezeOutput = execSync(`"${pipPath}" freeze`, { stdio: 'pipe', cwd: libPythonDir });
-      installedPkgs = freezeOutput.toString().split('\n')
-        .map(line => line.split('==')[0].toLowerCase().trim())
-        .filter(Boolean);
-    } catch { /* ignore */ }
-
-    // Filter out already installed packages
-    const toInstall = requirements.filter(pkg => {
-      const pkgName = pkg.split(/[>=<\[]/)[0].toLowerCase();
-      return !installedPkgs.includes(pkgName);
-    });
-
-    if (toInstall.length === 0) {
-      spinner.succeed(`Python ready: ${requirements.length} packages already installed`);
-      return { success: true, version: pythonVersion };
+    if (isProtected(targetPath)) {
+      changes.protected.push({ source: file, target: targetPath });
+    } else if (!fs.existsSync(fullTargetPath)) {
+      changes.new.push({ source: file, target: targetPath });
+    } else {
+      // Check if file changed
+      const sourceContent = fs.readFileSync(path.join(sourceDir, file));
+      const sourceHash = crypto.createHash('md5').update(sourceContent).digest('hex');
+      const targetHash = manifest.files?.[targetPath];
+
+      if (sourceHash !== targetHash) {
+        changes.update.push({ source: file, target: targetPath, hash: sourceHash });
+      } else {
+        changes.skip.push({ source: file, target: targetPath });
+      }
     }
+  }
 
-    // Install packages one by one with progress
-    spinner.stop();
-    const skipped = requirements.length - toInstall.length;
-    console.log(chalk.dim(`\n  Installing ${toInstall.length} packages (${skipped} already installed):\n`));
+  return changes;
+}
 
-    const installed = [];
-    const failed = [];
+function formatFileList(files, maxShow = 10) {
+  const lines = [];
+  const showFiles = files.slice(0, maxShow);
 
-    for (let i = 0; i < toInstall.length; i++) {
-      const pkg = toInstall[i];
-      const pkgName = pkg.split(/[>=<\[]/)[0]; // Extract package name
-      const progress = `[${i + 1}/${toInstall.length}]`;
+  for (const file of showFiles) {
+    lines.push(file.target || file);
+  }
 
-      process.stdout.write(`  ${chalk.dim(progress)} ${pkgName}... `);
+  if (files.length > maxShow) {
+    lines.push(chalk.dim(`... and ${files.length - maxShow} more`));
+  }
 
-      try {
-        execSync(`"${pipPath}" install "${pkg}" -q`, {
-          stdio: 'pipe',
-          cwd: libPythonDir,
-          timeout: 120000 // 2 min timeout per package
-        });
-        console.log(chalk.green('✓'));
-        installed.push(pkgName);
-      } catch (err) {
-        console.log(chalk.red('✗'));
-        const errMsg = err.stderr ? err.stderr.toString().split('\n')[0] : err.message;
-        console.log(chalk.dim(`       ${errMsg.slice(0, 60)}`));
-        failed.push(pkgName);
-      }
-    }
+  return lines;
+}
 
-    console.log('');
+// =============================================================================
+// Package Installation
+// =============================================================================
 
-    // Summary
-    const totalOk = installed.length + skipped;
-    if (failed.length === 0) {
-      spinner.succeed(`Python ready: ${totalOk} packages (${pythonVersion})`);
-      return { success: true, version: pythonVersion };
-    } else if (installed.length > 0 || skipped > 0) {
-      spinner.warn(`Partial: ${totalOk} ok, ${failed.length} failed`);
-      console.log(chalk.yellow(`  Failed: ${failed.join(', ')}`));
-      console.log(chalk.dim(`  Run manually: ${pipPath} install <package>\n`));
-      return { success: true, partial: true, version: pythonVersion, failed };
-    } else {
-      spinner.fail('All packages failed');
-      return { success: false, error: 'All packages failed to install' };
-    }
-  } catch (error) {
-    spinner.warn(`Python setup failed: ${error.message}`);
-    return { success: false, error: error.message };
+function checkPythonPackages(libPythonDir) {
+  const requirementsFile = path.join(libPythonDir, 'requirements.txt');
+  if (!fs.existsSync(requirementsFile)) {
+    return { required: [], installed: [], toInstall: [], toUpdate: [] };
   }
-}
 
-/**
- * Remap source paths to .claude/ destinations
- * Downloads directly to Claude Code directories
- */
-function remapPath(filePath) {
-  const mappings = [
-    { from: 'src/commands/', to: '.claude/commands/' },
-    { from: 'core/', to: '.claude/skills/csk/core/' },
-    { from: 'domains/', to: '.claude/skills/csk/domains/' },
-    { from: 'industries/', to: '.claude/skills/csk/industries/' }
-  ];
+  const platform = getPlatform();
+  const venvPath = path.join(libPythonDir, '.venv');
+  const pipPath = platform === 'windows'
+    ? path.join(venvPath, 'Scripts', 'pip.exe')
+    : path.join(venvPath, 'bin', 'pip');
 
-  for (const { from, to } of mappings) {
-    if (filePath.startsWith(from)) {
-      return filePath.replace(from, to);
+  // Parse requirements
+  const required = fs.readFileSync(requirementsFile, 'utf8')
+    .split('\n')
+    .map(line => line.split('#')[0].trim())
+    .filter(line => line && !line.startsWith('#'));
+
+  // Get installed packages
+  let installed = [];
+  let installedVersions = {};
+
+  if (fs.existsSync(venvPath)) {
+    try {
+      const freeze = execSync(`"${pipPath}" freeze`, { stdio: 'pipe' }).toString();
+      freeze.split('\n').forEach(line => {
+        const match = line.match(/^([^=]+)==(.+)$/);
+        if (match) {
+          installed.push(match[1].toLowerCase());
+          installedVersions[match[1].toLowerCase()] = match[2];
+        }
+      });
+    } catch {}
+  }
+
+  // Compare
+  const toInstall = [];
+  const toUpdate = [];
+  const alreadyOk = [];
+
+  for (const req of required) {
+    const pkgName = req.split(/[>=<\[]/)[0].toLowerCase();
+    const reqVersion = req.match(/[>=<]+(.+)/)?.[1];
+
+    if (!installed.includes(pkgName)) {
+      toInstall.push({ name: pkgName, required: req });
+    } else if (reqVersion && installedVersions[pkgName] !== reqVersion) {
+      toUpdate.push({
+        name: pkgName,
+        current: installedVersions[pkgName],
+        required: reqVersion
+      });
+    } else {
+      alreadyOk.push({ name: pkgName, version: installedVersions[pkgName] });
     }
   }
 
-  // Keep other files as-is (lib/, cli/, config/, etc.)
-  return filePath;
+  return { required, installed: alreadyOk, toInstall, toUpdate };
 }
 
-/**
- * Recursively copy directory
- */
-function copyDirRecursive(src, dest) {
-  const entries = fs.readdirSync(src, { withFileTypes: true });
+async function installPackages(libPythonDir, packages, timeline, stepIndex, pythonCmd = 'python3') {
+  const platform = getPlatform();
+  const venvPath = path.join(libPythonDir, '.venv');
+  const pipPath = platform === 'windows'
+    ? path.join(venvPath, 'Scripts', 'pip.exe')
+    : path.join(venvPath, 'bin', 'pip');
 
-  for (const entry of entries) {
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
+  // Create venv if not exists
+  if (!fs.existsSync(venvPath)) {
+    try {
+      execSync(`${pythonCmd} -m venv "${venvPath}"`, { stdio: 'pipe', cwd: libPythonDir });
+      timeline.addChild(stepIndex, 'Created virtual environment', 'new');
+    } catch (error) {
+      timeline.addChild(stepIndex, `Failed to create venv: ${error.message}`, 'skip');
+      return false;
+    }
+  }
 
-    if (entry.isDirectory()) {
-      ensureDir(destPath);
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      fs.copyFileSync(srcPath, destPath);
+  // Install packages
+  let success = true;
+  for (const pkg of packages) {
+    const pkgSpec = pkg.required || pkg.name;
+    try {
+      execSync(`"${pipPath}" install "${pkgSpec}" -q`, {
+        stdio: 'pipe',
+        cwd: libPythonDir,
+        timeout: 120000
+      });
+      timeline.addChild(stepIndex, `${pkg.name}`, 'new');
+    } catch (error) {
+      timeline.addChild(stepIndex, `${pkg.name} (failed)`, 'skip');
+      success = false;
     }
   }
+
+  return success;
 }
 
-/**
- * Main init command handler
- */
+// =============================================================================
+// Main Init Command
+// =============================================================================
+
 async function initCommand(options) {
   const projectDir = process.cwd();
+  const platform = getPlatform();
 
   console.log(chalk.cyan('\n  Content Suite Kit - Init\n'));
+  console.log(chalk.dim(`  Platform: ${platform}\n`));
 
-  // Check authentication
-  const spinner = ora('Checking authentication...').start();
+  // Initialize timeline
+  const timeline = new Timeline();
+  timeline.addStep('Authenticate');
+  timeline.addStep('Download package');
+  timeline.addStep('Extract files');
+  timeline.addStep('Scan changes');
+  timeline.addStep('Confirm changes');
+  timeline.addStep('Apply changes');
+  timeline.addStep('Setup dependencies');
+
+  // Step 1: Authenticate
+  timeline.start(0);
 
   const token = await getToken();
   if (!token) {
-    spinner.fail(chalk.red('Not authenticated'));
+    timeline.error(0, 'Not authenticated');
     console.log(chalk.dim('\n  Run `cskit auth --login` first.\n'));
     process.exit(1);
   }
 
   const { valid, error } = await verifyAccess(token);
   if (!valid) {
-    spinner.fail(chalk.red('Access denied'));
-    console.log(chalk.red(`\n  ${error}`));
+    timeline.error(0, error);
     process.exit(1);
   }
 
-  spinner.succeed('Authenticated');
+  timeline.complete(0, 'OK');
 
   // Check existing installation
   const manifest = loadManifest(projectDir);
   const isUpdate = manifest.version !== null;
 
   if (isUpdate) {
-    const currentVer = manifest.version.replace(/^v/, '');
-    console.log(chalk.dim(`\n  Current: v${currentVer} (${formatDate(manifest.installedAt)})\n`));
+    console.log(chalk.dim(`  Current: ${manifest.version} (${formatDate(manifest.installedAt)})\n`));
   }
 
-  // Fetch available versions
-  spinner.start('Fetching available versions...');
-
+  // Get available versions
   const releases = await getAllReleases(token);
   const latest = await getLatestRelease(token);
 
-  if (releases.length === 0) {
-    spinner.info('No releases found, using main branch');
-  } else {
-    spinner.succeed(`Found ${releases.length} release(s)`);
-  }
-
-  // Version selection (show max 5 recent releases)
+  // Version selection
   let selectedVersion = 'main';
-  const maxVersions = 5;
 
   if (releases.length > 0 && !options.latest) {
-    const recentReleases = releases.slice(0, maxVersions);
+    const recentReleases = releases.slice(0, 5);
     const choices = recentReleases.map((r, i) => ({
       name: `${r.tag}${i === 0 ? chalk.green(' (latest)') : ''} - ${formatDate(r.published)}`,
       value: r.tag
     }));
-
-    choices.push({ name: chalk.dim('main branch (development)'), value: 'main' });
+    choices.push({ name: chalk.dim('main branch (dev)'), value: 'main' });
 
     const answer = await inquirer.prompt([{
       type: 'list',
       name: 'version',
-      message: 'Select version to install:',
+      message: 'Select version:',
       choices,
       default: releases[0]?.tag || 'main'
     }]);
-
     selectedVersion = answer.version;
   } else if (latest) {
     selectedVersion = latest.tag;
@@ -301,110 +420,320 @@ async function initCommand(options) {
 
   console.log(chalk.dim(`\n  Installing: ${selectedVersion}\n`));
 
-  // Fetch file tree
-  spinner.start('Fetching file list...');
+  // Step 2: Download zip
+  timeline.start(1);
+
+  const tempDir = path.join(os.tmpdir(), `csk-${Date.now()}`);
+  const zipPath = path.join(tempDir, 'csk.zip');
+
+  ensureDir(tempDir);
+
+  try {
+    const zipBuffer = await downloadZipFromRef(token, selectedVersion);
+    fs.writeFileSync(zipPath, zipBuffer);
+    const sizeMB = (zipBuffer.length / 1024 / 1024).toFixed(2);
+    timeline.complete(1, `${sizeMB} MB`);
+  } catch (error) {
+    timeline.error(1, error.message);
+    process.exit(1);
+  }
+
+  // Step 3: Extract
+  timeline.start(2);
+
+  const extractDir = path.join(tempDir, 'extracted');
+  const result = await extractZip(zipPath, extractDir);
+
+  if (!result.success) {
+    timeline.error(2, result.error);
+    process.exit(1);
+  }
+
+  // Find the extracted folder (GitHub adds repo-branch prefix)
+  const extractedFolders = fs.readdirSync(extractDir);
+  const sourceDir = path.join(extractDir, extractedFolders[0]);
+
+  timeline.complete(2, `${extractedFolders[0]}`);
 
-  const tree = await getRepoTreeFromRef(token, selectedVersion);
-  const files = tree.filter(item =>
-    item.type === 'blob' && !shouldExclude(item.path)
-  );
+  // Step 4: Scan changes
+  timeline.start(3);
 
-  spinner.succeed(`Found ${files.length} files`);
+  const changes = compareFiles(sourceDir, projectDir, manifest);
 
-  // Download files with progress bar
-  console.log('');
+  timeline.addChild(3, `${changes.new.length} new files`, 'new');
+  timeline.addChild(3, `${changes.update.length} updates`, 'update');
+  timeline.addChild(3, `${changes.skip.length} unchanged`, 'info');
+
+  if (changes.protected.length > 0) {
+    timeline.addChild(3, `${changes.protected.length} protected (skip)`, 'skip');
+  }
+
+  timeline.complete(3, `${changes.new.length + changes.update.length} changes`);
+
+  // Step 5: Confirm changes
+  timeline.start(4);
+
+  // Show files that will be changed
+  if (changes.update.length > 0) {
+    console.log(chalk.yellow('\n  Files to be updated (will overwrite):\n'));
+    for (const file of changes.update.slice(0, 15)) {
+      console.log(chalk.yellow(`    ! ${file.target}`));
+    }
+    if (changes.update.length > 15) {
+      console.log(chalk.dim(`    ... and ${changes.update.length - 15} more\n`));
+    }
+    console.log('');
+  }
+
+  if (changes.new.length > 0) {
+    console.log(chalk.green('  New files to be created:\n'));
+    for (const file of changes.new.slice(0, 10)) {
+      console.log(chalk.green(`    + ${file.target}`));
+    }
+    if (changes.new.length > 10) {
+      console.log(chalk.dim(`    ... and ${changes.new.length - 10} more\n`));
+    }
+    console.log('');
+  }
+
+  // Confirm
+  if (changes.update.length > 0 && !options.force) {
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: `Overwrite ${changes.update.length} files?`,
+      default: true
+    }]);
+
+    if (!confirm) {
+      timeline.skip(4, 'User cancelled');
+      timeline.skip(5, 'Skipped');
+      timeline.skip(6, 'Skipped');
+
+      // Cleanup
+      fs.rmSync(tempDir, { recursive: true, force: true });
+
+      console.log(chalk.yellow('\n  Installation cancelled.\n'));
+      process.exit(0);
+    }
+  }
+
+  timeline.complete(4, 'Confirmed');
+
+  // Step 6: Apply changes
+  timeline.start(5);
 
-  const stats = { created: 0, updated: 0, skipped: 0, protected: 0, userModified: 0 };
   const newManifest = {
     files: {},
     version: selectedVersion,
     installedAt: new Date().toISOString()
   };
 
-  for (let i = 0; i < files.length; i++) {
-    const file = files[i];
-    const relativePath = remapPath(file.path);
-    const targetPath = path.join(projectDir, relativePath);
+  let applied = 0;
 
-    // Update progress bar
-    process.stdout.write(`\r  ${progressBar(i + 1, files.length)} ${chalk.dim(`(${i + 1}/${files.length})`)}`);
+  // Apply new files
+  for (const file of changes.new) {
+    const sourcePath = path.join(sourceDir, file.source);
+    const targetPath = path.join(projectDir, file.target);
 
-    try {
-      const content = await downloadFileFromRef(token, file.path, selectedVersion);
-      const contentHash = crypto.createHash('md5').update(content).digest('hex');
-
-      const { action, reason } = options.force
-        ? { action: isProtected(relativePath) ? 'skip' : 'update', reason: 'forced' }
-        : determineMergeAction(targetPath, relativePath, content, manifest.files);
-
-      switch (action) {
-        case 'create':
-          ensureDir(path.dirname(targetPath));
-          fs.writeFileSync(targetPath, content);
-          stats.created++;
-          newManifest.files[relativePath] = contentHash;
-          break;
-
-        case 'update':
-          ensureDir(path.dirname(targetPath));
-          fs.writeFileSync(targetPath, content);
-          stats.updated++;
-          newManifest.files[relativePath] = contentHash;
-          break;
-
-        case 'skip':
-          if (reason === 'protected') stats.protected++;
-          else if (reason === 'user-modified') stats.userModified++;
-          else stats.skipped++;
-
-          if (manifest.files[relativePath]) {
-            newManifest.files[relativePath] = manifest.files[relativePath];
-          }
-          break;
-      }
-    } catch (err) {
-      // Silent fail for individual files
-    }
+    ensureDir(path.dirname(targetPath));
+    fs.copyFileSync(sourcePath, targetPath);
+
+    const content = fs.readFileSync(sourcePath);
+    const hash = crypto.createHash('md5').update(content).digest('hex');
+    newManifest.files[file.target] = hash;
+    applied++;
   }
 
-  // Clear progress line
-  process.stdout.write('\r' + ' '.repeat(60) + '\r');
+  // Apply updates
+  for (const file of changes.update) {
+    const sourcePath = path.join(sourceDir, file.source);
+    const targetPath = path.join(projectDir, file.target);
+
+    ensureDir(path.dirname(targetPath));
+    fs.copyFileSync(sourcePath, targetPath);
+
+    newManifest.files[file.target] = file.hash;
+    applied++;
+  }
+
+  // Keep unchanged files in manifest
+  for (const file of changes.skip) {
+    if (manifest.files?.[file.target]) {
+      newManifest.files[file.target] = manifest.files[file.target];
+    }
+  }
 
   // Save manifest
   saveManifest(projectDir, newManifest);
 
-  // Summary
-  console.log(chalk.cyan('  Summary\n'));
-  console.log(`  ${chalk.green('+')} Created:       ${stats.created}`);
-  console.log(`  ${chalk.blue('~')} Updated:       ${stats.updated}`);
-  if (stats.protected > 0) console.log(`  ${chalk.yellow('!')} Protected:     ${stats.protected}`);
-  if (stats.userModified > 0) console.log(`  ${chalk.yellow('!')} User modified: ${stats.userModified}`);
-  if (stats.skipped > 0) console.log(`  ${chalk.dim('-')} Unchanged:     ${stats.skipped}`);
+  timeline.complete(5, `${applied} files`);
+
+  // Step 7: Setup dependencies
+  timeline.start(6);
+
+  const libPythonDir = path.join(projectDir, 'lib', 'python');
+
+  // Helper function to install Python packages
+  async function handlePythonPackages(pythonCmd) {
+    if (!fs.existsSync(libPythonDir)) {
+      timeline.skip(6, 'No lib/python folder');
+      return;
+    }
+
+    const { installAdvanced } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'installAdvanced',
+      message: 'Install Python dependencies?',
+      default: true
+    }]);
+
+    if (!installAdvanced) {
+      timeline.skip(6, 'Skipped by user');
+      return;
+    }
+
+    const pkgStatus = checkPythonPackages(libPythonDir);
+
+    if (pkgStatus.installed.length > 0) {
+      console.log(chalk.dim('\n  Already installed:'));
+      for (const pkg of pkgStatus.installed.slice(0, 5)) {
+        console.log(chalk.dim(`    ✓ ${pkg.name} (${pkg.version})`));
+      }
+      if (pkgStatus.installed.length > 5) {
+        console.log(chalk.dim(`    ... and ${pkgStatus.installed.length - 5} more\n`));
+      }
+    }
+
+    const allToInstall = [...pkgStatus.toInstall, ...pkgStatus.toUpdate];
+
+    if (allToInstall.length === 0) {
+      timeline.complete(6, 'All packages ready');
+      return;
+    }
+
+    console.log(chalk.cyan('\n  Packages to install/update:\n'));
+    for (const pkg of allToInstall) {
+      if (pkg.current) {
+        console.log(`    ${pkg.name}: ${pkg.current} → ${pkg.required}`);
+      } else {
+        console.log(`    ${pkg.name}: ${pkg.required || 'latest'}`);
+      }
+    }
+    console.log('');
+
+    const { confirmPkgs } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirmPkgs',
+      message: `Install ${allToInstall.length} packages?`,
+      default: true
+    }]);
+
+    if (confirmPkgs) {
+      await installPackages(libPythonDir, allToInstall, timeline, 6, pythonCmd);
+      timeline.complete(6, `${allToInstall.length} packages`);
+    } else {
+      timeline.skip(6, 'User skipped');
+    }
+  }
+
+  // Check Python availability first
+  let pythonInfo = detectPython();
+  let pythonReady = false;
 
-  // Setup Python environment
-  console.log('');
-  const pythonResult = await setupPythonEnv(projectDir, spinner);
+  if (!pythonInfo.found) {
+    console.log('');
+    console.log(chalk.yellow('  Python not found on this system.'));
+    console.log(chalk.dim('  Python is required for:'));
+    console.log(chalk.dim('    - Data fetching and analysis'));
+    console.log(chalk.dim('    - Chart generation'));
+    console.log(chalk.dim('    - MCP server tools'));
+    console.log('');
 
-  // CSK files already downloaded to .claude/ (no copy needed)
-  spinner.succeed('CSK installed to .claude/');
+    // Check if we can auto-install
+    const autoInstall = canAutoInstall();
 
-  // Success message
+    if (autoInstall.canInstall) {
+      console.log(chalk.cyan(`  Auto-install available via ${autoInstall.manager}`));
+      if (autoInstall.needsSudo) {
+        console.log(chalk.dim('  (requires sudo password)'));
+      }
+      console.log(chalk.dim(`  Command: ${autoInstall.command}`));
+      console.log('');
+
+      const { doInstall } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'doInstall',
+        message: `Install Python now via ${autoInstall.manager}?`,
+        default: true
+      }]);
+
+      if (doInstall) {
+        console.log('');
+        timeline.addChild(6, `Installing via ${autoInstall.manager}...`, 'update');
+
+        const result = await installPython((msg) => {
+          console.log(chalk.dim(`  ${msg}`));
+        });
+
+        if (result.success) {
+          pythonInfo = detectPython();
+          timeline.addChild(6, `Python ${result.version} installed`, 'new');
+          pythonReady = true;
+        } else {
+          console.log('');
+          console.log(chalk.red(`  ${result.error}`));
+          console.log(chalk.dim('  You may need to restart your terminal after installation.'));
+          console.log('');
+          timeline.skip(6, 'Installation failed');
+        }
+      } else {
+        timeline.skip(6, 'User declined install');
+      }
+    } else {
+      // No package manager - show manual instructions
+      const instructions = getInstallInstructions();
+      console.log(chalk.bold(`  Install via ${instructions.method}:\n`));
+      for (const cmd of instructions.commands.slice(0, 4)) {
+        if (cmd.startsWith('#')) {
+          console.log(chalk.dim(`  ${cmd}`));
+        } else if (cmd !== '') {
+          console.log(chalk.cyan(`    ${cmd}`));
+        }
+      }
+      console.log('');
+      timeline.skip(6, 'Python not installed');
+    }
+  } else if (!pythonInfo.meetsMinimum) {
+    console.log('');
+    console.log(chalk.yellow(`  Python ${pythonInfo.version} found, but 3.8+ required.`));
+    console.log(chalk.dim('  Please upgrade Python to use advanced features.'));
+    console.log('');
+    timeline.skip(6, `Python ${pythonInfo.version} too old`);
+  } else {
+    pythonReady = true;
+  }
+
+  // Install packages if Python is ready
+  if (pythonReady && pythonInfo.meetsMinimum) {
+    timeline.addChild(6, `Python ${pythonInfo.version} (${pythonInfo.command})`, 'update');
+    await handlePythonPackages(pythonInfo.command);
+  }
+
+  // Cleanup temp files
+  try {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  } catch {}
+
+  // Final message
   const ver = selectedVersion.replace(/^v/, '');
   console.log(chalk.green(`\n  ✓ CSK v${ver} ${isUpdate ? 'updated' : 'installed'} successfully!\n`));
 
-  // Quick start guide
   console.log(chalk.cyan('  Quick Start\n'));
-  console.log(chalk.dim('  1. Open Claude Code in this directory:'));
+  console.log(chalk.dim('  1. Open Claude Code:'));
   console.log(`     ${chalk.white('claude')}\n`);
-  console.log(chalk.dim('  2. Start with CSK command:'));
+  console.log(chalk.dim('  2. Start with CSK:'));
   console.log(`     ${chalk.white('/csk')}\n`);
-  console.log(chalk.dim('  3. Or explore available skills:'));
-  console.log(`     ${chalk.white('./cli/csk list')}\n`);
-
-  if (pythonResult.skipped && pythonResult.reason) {
-    console.log(chalk.dim(`  Note: ${pythonResult.reason}`));
-    console.log(chalk.dim('  Run manually: cd lib/python && python3 -m venv .venv && .venv/bin/pip install -r requirements.txt\n'));
-  }
 }
 
 module.exports = initCommand;