wtf-p 0.1.0 → 0.2.0

package/bin/install.js

@@ -3,39 +3,51 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const readline = require('readline');
 
-// Colors
-const cyan = '\x1b[36m';
-const green = '\x1b[32m';
-const yellow = '\x1b[33m';
-const red = '\x1b[31m';
-const magenta = '\x1b[35m';
-const dim = '\x1b[2m';
-const reset = '\x1b[0m';
+const {
+  expandTilde,
+  normalizePath,
+  isValidPath,
+  getClaudeDir,
+  getPathLabel,
+  readInstalledVersion,
+  writeVersionFile,
+  detectInstallation,
+  collectFiles,
+  createColors,
+  createOutput,
+  createRL,
+  prompt,
+  getBackupPath
+} = require('./lib/utils');
 
 // Get version from package.json
 const pkg = require('../package.json');
 
-const banner = `
-${magenta}██╗    ██╗████████╗███████╗      ██████╗
-██║    ██║╚══██╔══╝██╔════╝      ██╔══██╗
-██║ █╗ ██║   ██║   █████╗  █████╗██████╔╝
-██║███╗██║   ██║   ██╔══╝  ╚════╝██╔═══╝
-╚███╔███╔╝   ██║   ██║           ██║
- ╚══╝╚══╝    ╚═╝   ╚═╝           ╚═╝${reset}
-
-  ${cyan}Write The F***ing Paper${reset} ${dim}v${pkg.version}${reset}
-  Context engineering for academic writing.
-  Ship papers, not excuses.
-`;
+// ============ Argument Parsing ============
 
-// Parse args
 const args = process.argv.slice(2);
+
+// Detect subcommand (first non-flag argument)
+const subcommand = args.find(arg => !arg.startsWith('-') && ['status', 'doctor', 'update'].includes(arg));
+const subcommandIndex = args.indexOf(subcommand);
+if (subcommandIndex !== -1) {
+  args.splice(subcommandIndex, 1);
+}
+
+// Parse flags
 const hasGlobal = args.includes('--global') || args.includes('-g');
 const hasLocal = args.includes('--local') || args.includes('-l');
 const hasForce = args.includes('--force') || args.includes('-f');
 const hasBackupAll = args.includes('--backup-all') || args.includes('-b');
+const hasHelp = args.includes('--help') || args.includes('-h');
+const hasVersion = args.includes('--version') || args.includes('-v');
+const hasList = args.includes('--list');
+const hasNoColor = args.includes('--no-color');
+const hasQuiet = args.includes('--quiet') || args.includes('-q');
+const hasVerbose = args.includes('--verbose');
+const hasBeginner = args.includes('--beginner');
+const hasAdvanced = args.includes('--advanced');
 
 // Parse --config-dir argument
 function parseConfigDirArg() {
@@ -43,7 +55,7 @@ function parseConfigDirArg() {
   if (configDirIndex !== -1) {
     const nextArg = args[configDirIndex + 1];
     if (!nextArg || nextArg.startsWith('-')) {
-      console.error(`  ${yellow}--config-dir requires a path argument${reset}`);
+      console.error('  --config-dir requires a path argument');
       process.exit(1);
     }
     return nextArg;
@@ -54,96 +66,411 @@ function parseConfigDirArg() {
   }
   return null;
 }
+
+// Parse --only argument
+function parseOnlyArg() {
+  const onlyArg = args.find(arg => arg.startsWith('--only='));
+  if (onlyArg) {
+    const value = onlyArg.split('=')[1];
+    if (!['commands', 'workflows', 'all'].includes(value)) {
+      console.error('  --only must be: commands, workflows, or all');
+      process.exit(1);
+    }
+    return value;
+  }
+  return 'all';
+}
+
 const explicitConfigDir = parseConfigDirArg();
-const hasHelp = args.includes('--help') || args.includes('-h');
+const onlyInstall = parseOnlyArg();
+
+// Determine if interactive mode (TTY + not quiet/advanced)
+const isTTY = process.stdout.isTTY && process.stdin.isTTY;
+const isInteractive = isTTY && !hasQuiet && !hasAdvanced;
+const showExplanations = hasBeginner || (isInteractive && !hasAdvanced);
+
+// Setup output helpers
+const useColors = !hasNoColor && (isTTY || process.env.FORCE_COLOR);
+const out = createOutput({ quiet: hasQuiet, verbose: hasVerbose, useColors });
+const c = out.colors;
+
+// ============ Banner ============
+
+const banner = `
+${c.magenta('██╗    ██╗████████╗███████╗      ██████╗')}
+${c.magenta('██║    ██║╚══██╔══╝██╔════╝      ██╔══██╗')}
+${c.magenta('██║ █╗ ██║   ██║   █████╗  █████╗██████╔╝')}
+${c.magenta('██║███╗██║   ██║   ██╔══╝  ╚════╝██╔═══╝')}
+${c.magenta('╚███╔███╔╝   ██║   ██║           ██║')}
+${c.magenta(' ╚══╝╚══╝    ╚═╝   ╚═╝           ╚═╝')}
+
+  ${c.cyan('Write The F***ing Paper')} ${c.dim(`v${pkg.version}`)}
+  Context engineering for academic writing.
+`;
 
-console.log(banner);
+// ============ Help Text ============
 
-// Show help if requested
-if (hasHelp) {
-  console.log(`  ${yellow}Usage:${reset} npx wtf-p [options]
+function showHelp() {
+  console.log(banner);
+  console.log(`  ${c.yellow('Usage:')} npx wtf-p [command] [options]
 
-  ${yellow}Options:${reset}
-    ${cyan}-g, --global${reset}              Install globally (to Claude config directory)
-    ${cyan}-l, --local${reset}               Install locally (to ./.claude in current directory)
-    ${cyan}-c, --config-dir <path>${reset}   Specify custom Claude config directory
-    ${cyan}-f, --force${reset}               Overwrite all existing files without prompting
-    ${cyan}-b, --backup-all${reset}          Backup all existing files before overwriting
-    ${cyan}-h, --help${reset}                Show this help message
+  ${c.yellow('Commands:')}
+    ${c.cyan('status')}                    Show current installation state
+    ${c.cyan('doctor')}                    Diagnose installation issues
+    ${c.cyan('update')}                    Update existing installation
 
-  ${yellow}Conflict Resolution:${reset}
-    When existing WTF-P files are detected, you'll be prompted for each:
-    ${dim}[o]verwrite${reset}  - Replace with new version
-    ${dim}[s]kip${reset}       - Keep existing file
-    ${dim}[b]ackup${reset}     - Backup existing, then install new
-    ${dim}[a]ll${reset}        - Apply same choice to remaining conflicts
+  ${c.yellow('Install Options:')}
+    ${c.cyan('-g, --global')}              Install globally (to Claude config directory)
+    ${c.cyan('-l, --local')}               Install locally (to ./.claude in current directory)
+    ${c.cyan('-c, --config-dir <path>')}   Specify custom Claude config directory
+    ${c.cyan('-f, --force')}               Overwrite all existing files without prompting
+    ${c.cyan('-b, --backup-all')}          Backup all existing files before overwriting
+    ${c.cyan('--only=<type>')}             Install only: commands, workflows, or all
 
-  ${yellow}Examples:${reset}
-    ${dim}# Install with prompts for conflicts${reset}
-    npx wtf-p --global
+  ${c.yellow('Output Options:')}
+    ${c.cyan('--beginner')}                Show detailed explanations
+    ${c.cyan('--advanced')}                Minimal output, skip confirmations
+    ${c.cyan('--no-color')}                Disable colored output
+    ${c.cyan('-q, --quiet')}               Suppress non-essential output
+    ${c.cyan('--verbose')}                 Show detailed progress
 
-    ${dim}# Force overwrite all existing files${reset}
-    npx wtf-p --global --force
+  ${c.yellow('Other:')}
+    ${c.cyan('--list')}                    Preview what would be installed
+    ${c.cyan('-v, --version')}             Show version information
+    ${c.cyan('-h, --help')}                Show this help message
 
-    ${dim}# Backup all existing files before installing${reset}
-    npx wtf-p --global --backup-all
+  ${c.yellow('Examples:')}
+    ${c.dim('# Interactive install with prompts')}
+    npx wtf-p
 
-    ${dim}# Install to custom config directory${reset}
-    npx wtf-p --global --config-dir ~/.claude-research
+    ${c.dim('# Quick global install')}
+    npx wtf-p --global --advanced
 
-  ${yellow}Uninstall:${reset}
-    npx wtf-p-uninstall [--global|--local] [--config-dir <path>]
+    ${c.dim('# Install only commands')}
+    npx wtf-p --global --only=commands
 
-  ${yellow}After installation:${reset}
-    Run ${cyan}/wtfp:help${reset} in Claude Code to get started.
+    ${c.dim('# Check installation status')}
+    npx wtf-p status
+
+    ${c.dim('# Diagnose issues')}
+    npx wtf-p doctor
+
+  ${c.yellow('After installation:')}
+    Run ${c.cyan('/wtfp:help')} in Claude Code to get started.
 `);
-  process.exit(0);
 }
 
-/**
- * Expand ~ to home directory
- */
-function expandTilde(filePath) {
-  if (filePath && filePath.startsWith('~/')) {
-    return path.join(os.homedir(), filePath.slice(2));
+// ============ Version Info ============
+
+async function showVersion() {
+  console.log(`wtf-p v${pkg.version}`);
+
+  // Check for updates (non-blocking)
+  try {
+    const { execSync } = require('child_process');
+    const latest = execSync('npm view wtf-p version 2>/dev/null', { encoding: 'utf8' }).trim();
+    if (latest && latest !== pkg.version) {
+      console.log(`${c.yellow('Update available:')} ${pkg.version} → ${c.green(latest)}`);
+      console.log(`Run: ${c.cyan('npx wtf-p update')}`);
+    }
+  } catch {
+    // Ignore - can't check npm
   }
-  return filePath;
 }
 
-/**
- * Create readline interface for prompts
- */
-function createRL() {
-  return readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
+// ============ Status Command ============
+
+async function showStatus() {
+  if (!hasQuiet) console.log(banner);
+
+  const locations = [];
+
+  // Check global
+  const globalDir = getClaudeDir(explicitConfigDir, true);
+  const globalDetection = detectInstallation(globalDir);
+  locations.push({
+    label: 'Global',
+    path: globalDir,
+    pathLabel: getPathLabel(globalDir, true),
+    ...globalDetection
   });
+
+  // Check local if different
+  const localDir = getClaudeDir(null, false);
+  if (localDir !== globalDir) {
+    const localDetection = detectInstallation(localDir);
+    locations.push({
+      label: 'Local',
+      path: localDir,
+      pathLabel: getPathLabel(localDir, false),
+      ...localDetection
+    });
+  }
+
+  out.log(`  ${c.yellow('WTF-P Installation Status')}\n`);
+
+  for (const loc of locations) {
+    const installed = loc.hasCommands || loc.hasSkill;
+
+    out.log(`  ${c.cyan(loc.label)} ${c.dim(`(${loc.pathLabel})`)}`);
+
+    if (!installed) {
+      out.log(`    ${c.dim('Not installed')}\n`);
+      continue;
+    }
+
+    // Version
+    if (loc.version) {
+      const versionLabel = loc.version === 'legacy' ? 'legacy (pre-0.2.0)' : loc.version;
+      out.log(`    Version: ${c.green(versionLabel)}`);
+    }
+
+    // Components
+    const components = [];
+    if (loc.hasCommands) components.push(`commands (${loc.commandFiles.length} files)`);
+    if (loc.hasSkill) components.push(`workflows (${loc.skillFiles.length} files)`);
+    out.log(`    Installed: ${components.join(', ')}`);
+
+    // Warnings
+    if (loc.partial) {
+      out.log(`    ${c.yellow('⚠ Partial installation detected')}`);
+    }
+    if (loc.corrupt) {
+      out.log(`    ${c.red('⚠ Corrupt version file')}`);
+    }
+
+    out.log('');
+  }
+
+  // Check for updates
+  try {
+    const { execSync } = require('child_process');
+    const latest = execSync('npm view wtf-p version 2>/dev/null', { encoding: 'utf8' }).trim();
+    if (latest && latest !== pkg.version) {
+      out.log(`  ${c.yellow('Update available:')} ${pkg.version} → ${c.green(latest)}`);
+      out.log(`  Run: ${c.cyan('npx wtf-p update --global')}\n`);
+    }
+  } catch {
+    // Ignore
+  }
 }
 
-/**
- * Prompt user with a question
- */
-function prompt(rl, question) {
-  return new Promise(resolve => {
-    rl.question(question, answer => resolve(answer.trim().toLowerCase()));
-  });
+// ============ Doctor Command ============
+
+async function runDoctor() {
+  if (!hasQuiet) console.log(banner);
+
+  out.log(`  ${c.yellow('WTF-P Installation Doctor')}\n`);
+
+  const issues = [];
+  const checks = [];
+
+  // Check 1: Node.js version
+  const nodeVersion = process.version;
+  const nodeMajor = parseInt(nodeVersion.slice(1).split('.')[0], 10);
+  if (nodeMajor < 16) {
+    issues.push(`Node.js ${nodeVersion} is below minimum (16.7.0)`);
+    checks.push({ name: 'Node.js version', status: 'fail', detail: nodeVersion });
+  } else {
+    checks.push({ name: 'Node.js version', status: 'pass', detail: nodeVersion });
+  }
+
+  // Check 2: Claude directory exists
+  const globalDir = getClaudeDir(explicitConfigDir, true);
+  if (fs.existsSync(globalDir)) {
+    checks.push({ name: 'Claude config directory', status: 'pass', detail: getPathLabel(globalDir, true) });
+  } else {
+    checks.push({ name: 'Claude config directory', status: 'warn', detail: 'Does not exist (will be created on install)' });
+  }
+
+  // Check 3: Write permissions
+  const testDir = globalDir.replace(/\.claude$/, '.claude-test-' + Date.now());
+  try {
+    fs.mkdirSync(testDir, { recursive: true });
+    fs.writeFileSync(path.join(testDir, 'test'), 'test');
+    fs.rmSync(testDir, { recursive: true });
+    checks.push({ name: 'Write permissions', status: 'pass', detail: 'Can write to config directory' });
+  } catch (err) {
+    issues.push(`Cannot write to ${getPathLabel(globalDir, true)}: ${err.message}`);
+    checks.push({ name: 'Write permissions', status: 'fail', detail: err.message });
+  }
+
+  // Check 4: Installation state
+  const detection = detectInstallation(globalDir);
+  if (detection.hasCommands || detection.hasSkill) {
+    if (detection.partial) {
+      issues.push('Partial installation detected - some files are missing');
+      checks.push({ name: 'Installation integrity', status: 'warn', detail: 'Partial install' });
+    } else if (detection.corrupt) {
+      issues.push('Version file is corrupt - reinstall recommended');
+      checks.push({ name: 'Installation integrity', status: 'warn', detail: 'Corrupt version file' });
+    } else {
+      checks.push({ name: 'Installation integrity', status: 'pass', detail: `v${detection.version}` });
+    }
+  } else {
+    checks.push({ name: 'Installation integrity', status: 'info', detail: 'Not installed' });
+  }
+
+  // Check 5: CLAUDE_CONFIG_DIR env var
+  const configDirEnv = process.env.CLAUDE_CONFIG_DIR;
+  if (configDirEnv) {
+    const expanded = normalizePath(configDirEnv);
+    if (fs.existsSync(expanded)) {
+      checks.push({ name: 'CLAUDE_CONFIG_DIR', status: 'pass', detail: expanded });
+    } else {
+      issues.push(`CLAUDE_CONFIG_DIR points to non-existent path: ${configDirEnv}`);
+      checks.push({ name: 'CLAUDE_CONFIG_DIR', status: 'warn', detail: `${configDirEnv} (does not exist)` });
+    }
+  } else {
+    checks.push({ name: 'CLAUDE_CONFIG_DIR', status: 'info', detail: 'Not set (using default)' });
+  }
+
+  // Output results
+  for (const check of checks) {
+    let icon, color;
+    switch (check.status) {
+      case 'pass': icon = '✓'; color = c.green; break;
+      case 'fail': icon = '✗'; color = c.red; break;
+      case 'warn': icon = '⚠'; color = c.yellow; break;
+      default: icon = 'ℹ'; color = c.cyan;
+    }
+    out.log(`  ${color(icon)} ${check.name}: ${c.dim(check.detail)}`);
+  }
+
+  out.log('');
+
+  if (issues.length > 0) {
+    out.log(`  ${c.yellow('Issues found:')}`);
+    for (const issue of issues) {
+      out.log(`    ${c.yellow('•')} ${issue}`);
+    }
+    out.log('');
+    out.log(`  ${c.dim('Run')} ${c.cyan('npx wtf-p --global --force')} ${c.dim('to reinstall')}\n`);
+  } else {
+    out.log(`  ${c.green('No issues found!')}\n`);
+  }
 }
 
+// ============ Update Command ============
+
+async function runUpdate() {
+  if (!hasQuiet) console.log(banner);
+
+  out.log(`  ${c.yellow('Checking for updates...')}\n`);
+
+  // Find installed location
+  const globalDir = getClaudeDir(explicitConfigDir, true);
+  const localDir = getClaudeDir(null, false);
+
+  let targetDir = null;
+  let isGlobal = true;
+
+  const globalDetection = detectInstallation(globalDir);
+  const localDetection = detectInstallation(localDir);
+
+  if (hasGlobal || (!hasLocal && (globalDetection.hasCommands || globalDetection.hasSkill))) {
+    targetDir = globalDir;
+    isGlobal = true;
+  } else if (hasLocal || (localDetection.hasCommands || localDetection.hasSkill)) {
+    targetDir = localDir;
+    isGlobal = false;
+  }
+
+  if (!targetDir) {
+    out.log(`  ${c.yellow('No existing installation found.')}`);
+    out.log(`  Run ${c.cyan('npx wtf-p --global')} to install.\n`);
+    return;
+  }
+
+  const detection = isGlobal ? globalDetection : localDetection;
+  const currentVersion = detection.version === 'legacy' ? '0.0.0' : detection.version;
+
+  out.log(`  Current: ${c.dim(`v${currentVersion}`)} in ${c.dim(getPathLabel(targetDir, isGlobal))}`);
+  out.log(`  Package: ${c.dim(`v${pkg.version}`)}`);
+
+  if (pkg.version === currentVersion) {
+    out.log(`\n  ${c.green('Already up to date!')}\n`);
+    return;
+  }
+
+  out.log(`\n  ${c.cyan('Updating...')}\n`);
+
+  // Run install with backup
+  await install(isGlobal, true);
+}
+
+// ============ List Command ============
+
+function showList() {
+  if (!hasQuiet) console.log(banner);
+
+  const src = path.join(__dirname, '..');
+  const wtfpSrc = path.join(src, 'commands', 'wtfp');
+  const skillSrc = path.join(src, 'write-the-f-paper');
+
+  const files = [];
+
+  if (onlyInstall === 'all' || onlyInstall === 'commands') {
+    const commandFiles = collectFiles(wtfpSrc);
+    for (const f of commandFiles) {
+      files.push({ type: 'command', path: f.replace(wtfpSrc, 'commands/wtfp') });
+    }
+  }
+
+  if (onlyInstall === 'all' || onlyInstall === 'workflows') {
+    const skillFiles = collectFiles(skillSrc);
+    for (const f of skillFiles) {
+      files.push({ type: 'workflow', path: f.replace(skillSrc, 'write-the-f-paper') });
+    }
+  }
+
+  out.log(`  ${c.yellow('Files to install:')}\n`);
+
+  const commands = files.filter(f => f.type === 'command');
+  const workflows = files.filter(f => f.type === 'workflow');
+
+  if (commands.length > 0) {
+    out.log(`  ${c.cyan('Commands')} (${commands.length} files):`);
+    for (const f of commands.slice(0, 10)) {
+      out.log(`    ${c.dim(f.path)}`);
+    }
+    if (commands.length > 10) {
+      out.log(`    ${c.dim(`... and ${commands.length - 10} more`)}`);
+    }
+    out.log('');
+  }
+
+  if (workflows.length > 0) {
+    out.log(`  ${c.cyan('Workflows')} (${workflows.length} files):`);
+    for (const f of workflows.slice(0, 10)) {
+      out.log(`    ${c.dim(f.path)}`);
+    }
+    if (workflows.length > 10) {
+      out.log(`    ${c.dim(`... and ${workflows.length - 10} more`)}`);
+    }
+    out.log('');
+  }
+
+  out.log(`  Total: ${files.length} files\n`);
+}
+
+// ============ Installation ============
+
 /**
- * Generate backup path with timestamp
+ * Process file content with path replacement
  */
-function getBackupPath(filePath) {
-  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
-  const dir = path.dirname(filePath);
-  const ext = path.extname(filePath);
-  const base = path.basename(filePath, ext);
-  return path.join(dir, `${base}.backup-${timestamp}${ext}`);
+function processContent(srcPath, pathPrefix) {
+  if (srcPath.endsWith('.md') || srcPath.endsWith('.json')) {
+    let content = fs.readFileSync(srcPath, 'utf8');
+    return content.replace(/~\/\.claude\//g, pathPrefix);
+  }
+  return null;
 }
 
 /**
- * Collect all files that would be installed
+ * Collect files to install
  */
-function collectFiles(srcDir, destDir, pathPrefix, files = []) {
+function collectInstallFiles(srcDir, destDir, pathPrefix, files = []) {
   if (!fs.existsSync(srcDir)) return files;
 
   const entries = fs.readdirSync(srcDir, { withFileTypes: true });
@@ -153,7 +480,7 @@ function collectFiles(srcDir, destDir, pathPrefix, files = []) {
     const destPath = path.join(destDir, entry.name);
 
     if (entry.isDirectory()) {
-      collectFiles(srcPath, destPath, pathPrefix, files);
+      collectInstallFiles(srcPath, destPath, pathPrefix, files);
     } else {
       files.push({ src: srcPath, dest: destPath, name: entry.name });
     }
@@ -162,50 +489,44 @@ function collectFiles(srcDir, destDir, pathPrefix, files = []) {
   return files;
 }
 
-/**
- * Process file content with path replacement
- */
-function processContent(srcPath, pathPrefix) {
-  if (srcPath.endsWith('.md') || srcPath.endsWith('.json')) {
-    let content = fs.readFileSync(srcPath, 'utf8');
-    return content.replace(/~\/\.claude\//g, pathPrefix);
-  }
-  return null; // Binary copy
-}
-
 /**
  * Install files with conflict resolution
  */
 async function installWithConflictResolution(files, pathPrefix, claudeDir) {
   const rl = createRL();
-  let globalChoice = null; // 'overwrite', 'skip', 'backup'
+  let globalChoice = null;
   const stats = { installed: 0, skipped: 0, backed: 0 };
 
-  // Check for existing installation
   const existingFiles = files.filter(f => fs.existsSync(f.dest));
 
-  if (existingFiles.length > 0 && !hasForce && !hasBackupAll) {
-    const relPath = claudeDir.replace(os.homedir(), '~');
-    console.log(`  ${yellow}Found ${existingFiles.length} existing WTF-P file(s) in ${relPath}${reset}\n`);
+  if (existingFiles.length > 0 && !hasForce && !hasBackupAll && isInteractive) {
+    const relPath = getPathLabel(claudeDir, true);
+    out.log(`  ${c.yellow(`Found ${existingFiles.length} existing WTF-P file(s) in ${relPath}`)}\n`);
+
+    if (showExplanations) {
+      out.log(`  ${c.dim('For each file, choose:')}`);
+      out.log(`  ${c.dim('[o]verwrite - Replace with new version')}`);
+      out.log(`  ${c.dim('[s]kip      - Keep your existing file')}`);
+      out.log(`  ${c.dim('[b]ackup    - Save existing, then install new')}`);
+      out.log(`  ${c.dim('[a]ll       - Apply same choice to remaining')}\n`);
+    }
   }
 
   for (const file of files) {
     const exists = fs.existsSync(file.dest);
     const relDest = file.dest.replace(os.homedir(), '~').replace(process.cwd(), '.');
 
-    // Ensure directory exists
     fs.mkdirSync(path.dirname(file.dest), { recursive: true });
 
     if (exists && !hasForce && !hasBackupAll) {
       let choice = globalChoice;
 
-      if (!choice) {
+      if (!choice && isInteractive) {
         const answer = await prompt(rl,
-          `  ${yellow}?${reset} ${dim}${relDest}${reset} exists. [o]verwrite/[s]kip/[b]ackup/[a]ll: `
+          `  ${c.yellow('?')} ${c.dim(relDest)} exists. [o]verwrite/[s]kip/[b]ackup/[a]ll: `
         );
 
         if (answer.startsWith('a')) {
-          // Apply to all: ask which action
           const allAnswer = await prompt(rl,
             `    Apply to all: [o]verwrite/[s]kip/[b]ackup: `
           );
@@ -220,10 +541,13 @@ async function installWithConflictResolution(files, pathPrefix, claudeDir) {
         } else {
           choice = 'skip';
         }
+      } else if (!choice) {
+        // Non-interactive with existing file and no force: skip
+        choice = 'skip';
       }
 
       if (choice === 'skip') {
-        console.log(`  ${dim}○${reset} Skipped ${dim}${relDest}${reset}`);
+        out.verbose(`  ${c.dim('○')} Skipped ${c.dim(relDest)}`);
         stats.skipped++;
         continue;
       }
@@ -231,17 +555,16 @@ async function installWithConflictResolution(files, pathPrefix, claudeDir) {
       if (choice === 'backup') {
         const backupPath = getBackupPath(file.dest);
         fs.copyFileSync(file.dest, backupPath);
-        console.log(`  ${cyan}↻${reset} Backed up to ${dim}${path.basename(backupPath)}${reset}`);
+        out.log(`  ${c.cyan('↻')} Backed up to ${c.dim(path.basename(backupPath))}`);
         stats.backed++;
       }
     } else if (exists && hasBackupAll) {
       const backupPath = getBackupPath(file.dest);
       fs.copyFileSync(file.dest, backupPath);
-      console.log(`  ${cyan}↻${reset} Backed up ${dim}${relDest}${reset}`);
+      out.verbose(`  ${c.cyan('↻')} Backed up ${c.dim(relDest)}`);
       stats.backed++;
     }
 
-    // Install the file
     const content = processContent(file.src, pathPrefix);
     if (content !== null) {
       fs.writeFileSync(file.dest, content);
@@ -250,9 +573,9 @@ async function installWithConflictResolution(files, pathPrefix, claudeDir) {
     }
 
     if (!exists) {
-      console.log(`  ${green}+${reset} ${dim}${relDest}${reset}`);
+      out.verbose(`  ${c.green('+')} ${c.dim(relDest)}`);
     } else {
-      console.log(`  ${green}✓${reset} ${dim}${relDest}${reset}`);
+      out.verbose(`  ${c.green('✓')} ${c.dim(relDest)}`);
     }
     stats.installed++;
   }
@@ -262,69 +585,89 @@ async function installWithConflictResolution(files, pathPrefix, claudeDir) {
 }
 
 /**
- * Install to the specified directory
+ * Main install function
  */
-async function install(isGlobal) {
+async function install(isGlobal, isUpdate = false) {
   const src = path.join(__dirname, '..');
-  const configDir = expandTilde(explicitConfigDir) || expandTilde(process.env.CLAUDE_CONFIG_DIR);
-  const defaultGlobalDir = configDir || path.join(os.homedir(), '.claude');
-  const claudeDir = isGlobal
-    ? defaultGlobalDir
-    : path.join(process.cwd(), '.claude');
+  const claudeDir = getClaudeDir(explicitConfigDir, isGlobal);
+  const locationLabel = getPathLabel(claudeDir, isGlobal);
 
-  const locationLabel = isGlobal
-    ? claudeDir.replace(os.homedir(), '~')
-    : claudeDir.replace(process.cwd(), '.');
+  // Validate path
+  if (!isValidPath(claudeDir)) {
+    out.error(`Invalid path: ${claudeDir}`);
+    process.exit(1);
+  }
 
   const pathPrefix = isGlobal
-    ? (configDir ? `${claudeDir}/` : '~/.claude/')
+    ? (explicitConfigDir ? `${claudeDir}/` : '~/.claude/')
     : './.claude/';
 
-  console.log(`  Installing to ${cyan}${locationLabel}${reset}\n`);
+  if (!hasQuiet) {
+    out.log(`  Installing to ${c.cyan(locationLabel)}\n`);
+  }
 
-  // Collect all files to install
-  const wtfpSrc = path.join(src, 'commands', 'wtfp');
-  const wtfpDest = path.join(claudeDir, 'commands', 'wtfp');
-  const skillSrc = path.join(src, 'write-the-f-paper');
-  const skillDest = path.join(claudeDir, 'write-the-f-paper');
+  // Collect files based on --only flag
+  const allFiles = [];
 
-  const allFiles = [
-    ...collectFiles(wtfpSrc, wtfpDest, pathPrefix),
-    ...collectFiles(skillSrc, skillDest, pathPrefix)
-  ];
+  if (onlyInstall === 'all' || onlyInstall === 'commands') {
+    const wtfpSrc = path.join(src, 'commands', 'wtfp');
+    const wtfpDest = path.join(claudeDir, 'commands', 'wtfp');
+    collectInstallFiles(wtfpSrc, wtfpDest, pathPrefix, allFiles);
+  }
+
+  if (onlyInstall === 'all' || onlyInstall === 'workflows') {
+    const skillSrc = path.join(src, 'write-the-f-paper');
+    const skillDest = path.join(claudeDir, 'write-the-f-paper');
+    collectInstallFiles(skillSrc, skillDest, pathPrefix, allFiles);
+  }
 
   // Install with conflict resolution
   const stats = await installWithConflictResolution(allFiles, pathPrefix, claudeDir);
 
-  console.log(`
-  ${green}Done!${reset} Installed: ${stats.installed}, Skipped: ${stats.skipped}, Backed up: ${stats.backed}
+  // Write version tracking file
+  writeVersionFile(claudeDir, pkg.version, allFiles);
 
-  Run ${cyan}/wtfp:help${reset} in Claude Code to get started.
+  // Summary
+  if (!hasQuiet) {
+    out.log(`
+  ${c.green('Done!')} Installed: ${stats.installed}, Skipped: ${stats.skipped}, Backed up: ${stats.backed}
 
-  ${yellow}Quick Start:${reset}
-    ${cyan}/wtfp:new-paper${reset}      Start a new academic paper
-    ${cyan}/wtfp:progress${reset}       Check your writing status
-    ${cyan}/wtfp:help${reset}           Show all commands
+  Run ${c.cyan('/wtfp:help')} in Claude Code to get started.
 `);
+
+    if (showExplanations && !isUpdate) {
+      out.log(`  ${c.yellow('Quick Start:')}`);
+      out.log(`    ${c.cyan('/wtfp:new-paper')}      Start a new academic paper`);
+      out.log(`    ${c.cyan('/wtfp:progress')}       Check your writing status`);
+      out.log(`    ${c.cyan('/wtfp:help')}           Show all commands\n`);
+    }
+  }
 }
 
 /**
- * Prompt for install location
+ * Prompt for install location (interactive mode)
  */
 async function promptLocation() {
   const rl = createRL();
 
-  const configDir = expandTilde(explicitConfigDir) || expandTilde(process.env.CLAUDE_CONFIG_DIR);
-  const globalPath = configDir || path.join(os.homedir(), '.claude');
-  const globalLabel = globalPath.replace(os.homedir(), '~');
-
-  console.log(`  ${yellow}Where would you like to install?${reset}
+  const globalPath = getClaudeDir(explicitConfigDir, true);
+  const globalLabel = getPathLabel(globalPath, true);
 
-  ${cyan}1${reset}) Global ${dim}(${globalLabel})${reset} - available in all projects
-  ${cyan}2${reset}) Local  ${dim}(./.claude)${reset} - this project only
+  out.log(`  ${c.yellow('Where would you like to install?')}
 `);
 
-  const answer = await prompt(rl, `  Choice ${dim}[1]${reset}: `);
+  if (showExplanations) {
+    out.log(`  ${c.cyan('1)')} Global ${c.dim(`(${globalLabel})`)} - available in all projects`);
+    out.log(`     ${c.dim('Recommended for most users')}`);
+    out.log(`  ${c.cyan('2)')} Local  ${c.dim('(./.claude)')} - this project only`);
+    out.log(`     ${c.dim('Useful for project-specific configurations')}`);
+  } else {
+    out.log(`  ${c.cyan('1)')} Global ${c.dim(`(${globalLabel})`)} - available in all projects`);
+    out.log(`  ${c.cyan('2)')} Local  ${c.dim('(./.claude)')} - this project only`);
+  }
+  out.log('');
+
+  const answer = await prompt(rl, `  Choice ${c.dim('[1]')}: `);
   rl.close();
 
   const choice = answer || '1';
@@ -332,27 +675,83 @@ async function promptLocation() {
   await install(isGlobal);
 }
 
-// Main
+// ============ Main ============
+
 async function main() {
+  // Handle --version
+  if (hasVersion) {
+    await showVersion();
+    return;
+  }
+
+  // Handle --help
+  if (hasHelp) {
+    showHelp();
+    return;
+  }
+
+  // Handle subcommands
+  if (subcommand === 'status') {
+    await showStatus();
+    return;
+  }
+
+  if (subcommand === 'doctor') {
+    await runDoctor();
+    return;
+  }
+
+  if (subcommand === 'update') {
+    await runUpdate();
+    return;
+  }
+
+  // Handle --list
+  if (hasList) {
+    showList();
+    return;
+  }
+
+  // Show banner for install
+  if (!hasQuiet) {
+    console.log(banner);
+  }
+
+  // Validate conflicting flags
   if (hasGlobal && hasLocal) {
-    console.error(`  ${yellow}Cannot specify both --global and --local${reset}`);
+    out.error('Cannot specify both --global and --local');
+    process.exit(1);
+  }
+  if (explicitConfigDir && hasLocal) {
+    out.error('Cannot use --config-dir with --local');
     process.exit(1);
-  } else if (explicitConfigDir && hasLocal) {
-    console.error(`  ${yellow}Cannot use --config-dir with --local${reset}`);
+  }
+  if (hasForce && hasBackupAll) {
+    out.error('Cannot use both --force and --backup-all');
     process.exit(1);
-  } else if (hasForce && hasBackupAll) {
-    console.error(`  ${yellow}Cannot use both --force and --backup-all${reset}`);
+  }
+  if (hasBeginner && hasAdvanced) {
+    out.error('Cannot use both --beginner and --advanced');
     process.exit(1);
-  } else if (hasGlobal) {
+  }
+
+  // Run install
+  if (hasGlobal) {
     await install(true);
   } else if (hasLocal) {
     await install(false);
-  } else {
+  } else if (isInteractive) {
     await promptLocation();
+  } else {
+    // Non-interactive default: global
+    await install(true);
   }
 }
 
 main().catch(err => {
-  console.error(`  ${red}Error:${reset} ${err.message}`);
+  out.error(err.message);
+  if (hasVerbose) {
+    console.error(err.stack);
+  }
   process.exit(1);
 });