wtf-p 0.1.0 → 0.3.0

package/bin/install.js

@@ -1,358 +1,206 @@
 #!/usr/bin/env node
 
-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 {
+  createOutput,
+  createRL,
+  prompt,
+} = 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.
-`;
+// Command modules
+const showStatus = require('./commands/status');
+const runDoctor = require('./commands/doctor');
+const runUpdate = require('./commands/update');
+const install = require('./commands/install-logic');
+const showList = require('./commands/list');
+
+// ============ Argument Parsing ============ 
 
-// Parse args
 const args = process.argv.slice(2);
+
+// Detect subcommand
+const subcommands = ['status', 'doctor', 'update'];
+const subcommand = args.find(arg => !arg.startsWith('-') && subcommands.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() {
   const configDirIndex = args.findIndex(arg => arg === '--config-dir' || arg === '-c');
   if (configDirIndex !== -1) {
     const nextArg = args[configDirIndex + 1];
-    if (!nextArg || nextArg.startsWith('-')) {
-      console.error(`  ${yellow}--config-dir requires a path argument${reset}`);
-      process.exit(1);
-    }
-    return nextArg;
+    if (nextArg && !nextArg.startsWith('-')) return nextArg;
   }
   const configDirArg = args.find(arg => arg.startsWith('--config-dir=') || arg.startsWith('-c='));
-  if (configDirArg) {
-    return configDirArg.split('=')[1];
-  }
+  if (configDirArg) return configDirArg.split('=')[1];
   return null;
 }
-const explicitConfigDir = parseConfigDirArg();
-const hasHelp = args.includes('--help') || args.includes('-h');
-
-console.log(banner);
-
-// Show help if requested
-if (hasHelp) {
-  console.log(`  ${yellow}Usage:${reset} npx wtf-p [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
 
-  ${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
-
-  ${yellow}Examples:${reset}
-    ${dim}# Install with prompts for conflicts${reset}
-    npx wtf-p --global
-
-    ${dim}# Force overwrite all existing files${reset}
-    npx wtf-p --global --force
-
-    ${dim}# Backup all existing files before installing${reset}
-    npx wtf-p --global --backup-all
-
-    ${dim}# Install to custom config directory${reset}
-    npx wtf-p --global --config-dir ~/.claude-research
-
-  ${yellow}Uninstall:${reset}
-    npx wtf-p-uninstall [--global|--local] [--config-dir <path>]
-
-  ${yellow}After installation:${reset}
-    Run ${cyan}/wtfp:help${reset} 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));
-  }
-  return filePath;
+function parseOnlyArg() {
+  const onlyArg = args.find(arg => arg.startsWith('--only='));
+  if (onlyArg) return onlyArg.split('=')[1];
+  return 'all';
 }
 
-/**
- * Create readline interface for prompts
- */
-function createRL() {
-  return readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-}
+const options = {
+  explicitConfigDir: parseConfigDirArg(),
+  onlyInstall: parseOnlyArg(),
+  hasGlobal,
+  hasLocal,
+  hasForce,
+  hasBackupAll,
+  hasQuiet,
+  hasVerbose,
+  hasBeginner,
+  hasAdvanced,
+  isInteractive: process.stdout.isTTY && process.stdin.isTTY && !hasQuiet && !hasAdvanced,
+};
+options.showExplanations = options.hasBeginner || (options.isInteractive && !options.hasAdvanced);
+
+const useColors = !hasNoColor && (process.stdout.isTTY || process.env.FORCE_COLOR);
+const out = createOutput({ quiet: hasQuiet, verbose: hasVerbose, useColors });
+options.out = out;
+
+// ============ Banner ============ 
 
-/**
- * Prompt user with a question
- */
-function prompt(rl, question) {
-  return new Promise(resolve => {
-    rl.question(question, answer => resolve(answer.trim().toLowerCase()));
-  });
-}
+const banner = `
+${out.colors.magenta('██╗    ██╗████████╗███████╗      ██████╗')}
+${out.colors.magenta('██║    ██║╚══██╔══╝██╔════╝      ██╔══██╗')}
+${out.colors.magenta('██║ █╗ ██║   ██║   █████╗  █████╗██████╔╝')}
+${out.colors.magenta('██║███╗██║   ██║   ██╔══╝  ╚════╝██╔═══╝')}
+${out.colors.magenta('╚███╔███╔╝   ██║   ██║           ██║')}
+${out.colors.magenta(' ╚══╝╚══╝    ╚═╝   ╚═╝           ╚═╝')}
+
+  ${out.colors.cyan('Write The F***ing Paper')} ${out.colors.dim(`v${pkg.version}`)}
+  Context engineering for academic writing.
+`;
 
-/**
- * Generate backup path with timestamp
- */
-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}`);
+// ============ Help Text ============ 
+
+function showHelp() {
+  const c = out.colors;
+  console.log(banner);
+  console.log(`  ${c.yellow('Usage:')} npx wtf-p [command] [options] 
+
+  ${c.yellow('Commands:')}
+    ${c.cyan('status')}                    Show current installation state
+    ${c.cyan('doctor')}                    Diagnose installation issues
+    ${c.cyan('update')}                    Update existing installation
+
+  ${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
+
+  ${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
+
+  ${c.yellow('Other:')}
+    ${c.cyan('-v, --version')}             Show version information
+    ${c.cyan('-h, --help')}                Show this help message
+
+  ${c.yellow('Examples:')}
+    ${c.dim('# Interactive install with prompts')}
+    npx wtf-p
+
+    ${c.dim('# Quick global install')}
+    npx wtf-p --global --advanced
+
+  ${c.yellow('After installation:')}
+    Run ${c.cyan('/wtfp:help')} in Claude Code to get started.
+`);
 }
 
-/**
- * Collect all files that would be installed
- */
-function collectFiles(srcDir, destDir, pathPrefix, files = []) {
-  if (!fs.existsSync(srcDir)) return files;
+// ============ Main ============ 
 
-  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const srcPath = path.join(srcDir, entry.name);
-    const destPath = path.join(destDir, entry.name);
-
-    if (entry.isDirectory()) {
-      collectFiles(srcPath, destPath, pathPrefix, files);
-    } else {
-      files.push({ src: srcPath, dest: destPath, name: entry.name });
-    }
+async function main() {
+  if (hasVersion) {
+    console.log(`wtf-p v${pkg.version}`);
+    return;
   }
 
-  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);
+  if (hasHelp) {
+    showHelp();
+    return;
   }
-  return null; // Binary copy
-}
 
-/**
- * Install files with conflict resolution
- */
-async function installWithConflictResolution(files, pathPrefix, claudeDir) {
-  const rl = createRL();
-  let globalChoice = null; // 'overwrite', 'skip', 'backup'
-  const stats = { installed: 0, skipped: 0, backed: 0 };
+  // Handle --list
+  if (hasList) {
+    if (!hasQuiet) console.log(banner);
+    showList(options);
+    return;
+  }
 
-  // Check for existing installation
-  const existingFiles = files.filter(f => fs.existsSync(f.dest));
+  if (subcommand === 'status') {
+    if (!hasQuiet) console.log(banner);
+    await showStatus(options, pkg);
+    return;
+  }
 
-  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 (subcommand === 'doctor') {
+    if (!hasQuiet) console.log(banner);
+    await runDoctor(options);
+    return;
   }
 
-  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) {
-        const answer = await prompt(rl,
-          `  ${yellow}?${reset} ${dim}${relDest}${reset} 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: `
-          );
-          if (allAnswer.startsWith('o')) globalChoice = 'overwrite';
-          else if (allAnswer.startsWith('b')) globalChoice = 'backup';
-          else globalChoice = 'skip';
-          choice = globalChoice;
-        } else if (answer.startsWith('o')) {
-          choice = 'overwrite';
-        } else if (answer.startsWith('b')) {
-          choice = 'backup';
-        } else {
-          choice = 'skip';
-        }
-      }
-
-      if (choice === 'skip') {
-        console.log(`  ${dim}○${reset} Skipped ${dim}${relDest}${reset}`);
-        stats.skipped++;
-        continue;
-      }
-
-      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}`);
-        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}`);
-      stats.backed++;
-    }
-
-    // Install the file
-    const content = processContent(file.src, pathPrefix);
-    if (content !== null) {
-      fs.writeFileSync(file.dest, content);
-    } else {
-      fs.copyFileSync(file.src, file.dest);
-    }
-
-    if (!exists) {
-      console.log(`  ${green}+${reset} ${dim}${relDest}${reset}`);
-    } else {
-      console.log(`  ${green}✓${reset} ${dim}${relDest}${reset}`);
-    }
-    stats.installed++;
+  if (subcommand === 'update') {
+    if (!hasQuiet) console.log(banner);
+    await runUpdate(options, pkg, install);
+    return;
   }
 
-  rl.close();
-  return stats;
-}
+  // Default: Install
+  if (!hasQuiet) console.log(banner);
 
-/**
- * Install to the specified directory
- */
-async function install(isGlobal) {
-  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 locationLabel = isGlobal
-    ? claudeDir.replace(os.homedir(), '~')
-    : claudeDir.replace(process.cwd(), '.');
-
-  const pathPrefix = isGlobal
-    ? (configDir ? `${claudeDir}/` : '~/.claude/')
-    : './.claude/';
-
-  console.log(`  Installing to ${cyan}${locationLabel}${reset}\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');
-
-  const allFiles = [
-    ...collectFiles(wtfpSrc, wtfpDest, pathPrefix),
-    ...collectFiles(skillSrc, skillDest, pathPrefix)
-  ];
-
-  // 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}
-
-  Run ${cyan}/wtfp:help${reset} in Claude Code to get started.
-
-  ${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
+  if (hasGlobal) {
+    await install(true, false, options, pkg);
+  } else if (hasLocal) {
+    await install(false, false, options, pkg);
+  } else if (options.isInteractive) {
+    const rl = createRL();
+    out.log(`  ${out.colors.yellow('Where would you like to install?')} 
 `);
-}
-
-/**
- * Prompt for install location
- */
-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}
-
-  ${cyan}1${reset}) Global ${dim}(${globalLabel})${reset} - available in all projects
-  ${cyan}2${reset}) Local  ${dim}(./.claude)${reset} - this project only
+    out.log(`  ${out.colors.cyan('1)')} Global (~/.claude) - available in all projects`);
+    out.log(`  ${out.colors.cyan('2)')} Local  (./.claude) - this project only
 `);
-
-  const answer = await prompt(rl, `  Choice ${dim}[1]${reset}: `);
-  rl.close();
-
-  const choice = answer || '1';
-  const isGlobal = choice !== '2';
-  await install(isGlobal);
-}
-
-// Main
-async function main() {
-  if (hasGlobal && hasLocal) {
-    console.error(`  ${yellow}Cannot specify both --global and --local${reset}`);
-    process.exit(1);
-  } else if (explicitConfigDir && hasLocal) {
-    console.error(`  ${yellow}Cannot use --config-dir with --local${reset}`);
-    process.exit(1);
-  } else if (hasForce && hasBackupAll) {
-    console.error(`  ${yellow}Cannot use both --force and --backup-all${reset}`);
-    process.exit(1);
-  } else if (hasGlobal) {
-    await install(true);
-  } else if (hasLocal) {
-    await install(false);
+    
+    const answer = await prompt(rl, `  Choice ${out.colors.dim('[1]')}: `);
+    rl.close();
+    
+    const choice = answer || '1';
+    await install(choice !== '2', false, options, pkg);
   } else {
-    await promptLocation();
+    await install(true, false, options, pkg);
   }
 }
 
 main().catch(err => {
-  console.error(`  ${red}Error:${reset} ${err.message}`);
+  out.error(err.message);
+  if (hasVerbose) console.error(err.stack);
   process.exit(1);
-});
+});

package/bin/lib/manifest.js

@@ -0,0 +1,41 @@
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '../..');
+
+const MANIFEST = {
+  claude: {
+    name: 'Claude Code',
+    configDirEnv: 'CLAUDE_CONFIG_DIR',
+    defaultDir: '.claude',
+    components: [
+      {
+        id: 'workflows',
+        src: path.join(ROOT, 'core', 'write-the-f-paper'),
+        dest: 'write-the-f-paper',
+        type: 'dir'
+      },
+      {
+        id: 'commands',
+        src: path.join(ROOT, 'vendors', 'claude', 'commands', 'wtfp'),
+        dest: 'commands/wtfp',
+        type: 'dir'
+      },
+      {
+        id: 'skills',
+        src: path.join(ROOT, 'vendors', 'claude', 'skills', 'wtfp'),
+        dest: 'skills/wtfp',
+        type: 'dir'
+      },
+      {
+        id: 'plugin',
+        src: path.join(ROOT, 'vendors', 'claude', '.claude-plugin'),
+        dest: '.claude-plugin',
+        type: 'dir'
+      }
+    ]
+  },
+  // Future:
+  // gemini: { ... }
+};
+
+module.exports = MANIFEST;