viepilot 1.0.0

package/bin/viepilot.cjs

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+/**
+ * Guided installer entrypoint for `npx viepilot`.
+ */
+
+const path = require('path');
+const { spawnSync } = require('child_process');
+const readline = require('readline');
+
+const TARGETS = [
+  { id: 'claude-code', label: 'Claude Code' },
+  { id: 'cursor-agent', label: 'Cursor Agent' },
+  { id: 'cursor-ide', label: 'Cursor IDE' },
+];
+
+function printHelp() {
+  console.log(`
+ViePilot CLI
+
+Usage:
+  viepilot install [options]
+  viepilot --help
+  viepilot --list-targets
+
+Install options:
+  --target <id|id,id|all>   Target profile(s): claude-code,cursor-agent,cursor-ide
+  --yes                      Non-interactive mode (skip confirmations)
+  --dry-run                  Print actions only, do not execute installers
+  --list-targets             Print supported targets and exit
+  --help                     Show help
+`);
+}
+
+function printTargets() {
+  TARGETS.forEach((t) => {
+    console.log(`${t.id}\t${t.label}`);
+  });
+}
+
+function parseInstallArgs(args) {
+  const options = {
+    yes: false,
+    dryRun: false,
+    listTargets: false,
+    targets: null,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--yes') options.yes = true;
+    else if (arg === '--dry-run') options.dryRun = true;
+    else if (arg === '--list-targets') options.listTargets = true;
+    else if (arg === '--target') {
+      const value = args[i + 1];
+      if (!value) {
+        throw new Error('Missing value for --target');
+      }
+      options.targets = value;
+      i++;
+    } else if (arg === '--help' || arg === '-h') {
+      options.help = true;
+    } else {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+
+  return options;
+}
+
+function normalizeTargets(rawTargets) {
+  if (!rawTargets) return null;
+  if (rawTargets === 'all') return TARGETS.map((t) => t.id);
+  const allowed = new Set(TARGETS.map((t) => t.id));
+  const parsed = rawTargets.split(',').map((s) => s.trim()).filter(Boolean);
+  if (parsed.length === 0) throw new Error('No targets provided');
+  for (const item of parsed) {
+    if (!allowed.has(item)) throw new Error(`Unsupported target: ${item}`);
+  }
+  return [...new Set(parsed)];
+}
+
+function ask(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+async function interactiveTargetSelection() {
+  console.log('\nSelect install targets (comma-separated numbers):');
+  TARGETS.forEach((t, idx) => {
+    console.log(`  ${idx + 1}. ${t.label} (${t.id})`);
+  });
+  console.log('  4. All targets');
+  console.log('  0. Cancel');
+  const answer = await ask('Choice: ');
+
+  if (answer === '0') return [];
+  if (answer === '4') return TARGETS.map((t) => t.id);
+
+  const indexes = answer
+    .split(',')
+    .map((x) => Number(x.trim()))
+    .filter((n) => Number.isInteger(n) && n >= 1 && n <= TARGETS.length);
+
+  const selected = [...new Set(indexes.map((n) => TARGETS[n - 1].id))];
+  return selected;
+}
+
+function handlerForTarget(target) {
+  const root = path.join(__dirname, '..');
+  if (target === 'cursor-agent') {
+    return {
+      script: path.join(root, 'dev-install.sh'),
+      env: { VIEPILOT_AUTO_YES: '1', VIEPILOT_INSTALL_PROFILE: target },
+    };
+  }
+  return {
+    script: path.join(root, 'install.sh'),
+    env: { VIEPILOT_AUTO_YES: '1', VIEPILOT_INSTALL_PROFILE: target },
+  };
+}
+
+function runInstaller(target, dryRun) {
+  const config = handlerForTarget(target);
+  const commandLabel = `${config.script} [profile=${target}]`;
+  if (dryRun) {
+    console.log(`[dry-run] ${commandLabel}`);
+    return { ok: true, target, dryRun: true };
+  }
+
+  const result = spawnSync('bash', [config.script], {
+    stdio: 'inherit',
+    env: { ...process.env, ...config.env },
+    cwd: path.join(__dirname, '..'),
+  });
+  return { ok: result.status === 0, target, code: result.status ?? 1 };
+}
+
+async function installCommand(rawArgs) {
+  const options = parseInstallArgs(rawArgs);
+  if (options.help) {
+    printHelp();
+    return 0;
+  }
+  if (options.listTargets) {
+    printTargets();
+    return 0;
+  }
+
+  let selectedTargets = normalizeTargets(options.targets);
+
+  if (!selectedTargets) {
+    if (options.yes) {
+      selectedTargets = TARGETS.map((t) => t.id);
+      console.log('No --target provided with --yes; defaulting to all targets.');
+    } else {
+      selectedTargets = await interactiveTargetSelection();
+      if (selectedTargets.length === 0) {
+        console.log('Installation canceled.');
+        return 0;
+      }
+    }
+  }
+
+  console.log(`\nSelected targets: ${selectedTargets.join(', ')}`);
+  const results = selectedTargets.map((target) => runInstaller(target, options.dryRun));
+  const failed = results.filter((r) => !r.ok);
+
+  console.log('\nInstall summary:');
+  for (const r of results) {
+    if (r.ok && r.dryRun) console.log(`- ${r.target}: planned`);
+    else if (r.ok) console.log(`- ${r.target}: installed`);
+    else console.log(`- ${r.target}: failed (exit ${r.code})`);
+  }
+  console.log('\nNext actions:');
+  console.log('- Open project in Cursor/Claude and run /vp-status');
+  console.log('- If needed, run /vp-brainstorm then /vp-crystallize');
+
+  return failed.length === 0 ? 0 : 1;
+}
+
+async function main() {
+  const [, , command, ...rest] = process.argv;
+  if (!command || command === '--help' || command === '-h') {
+    printHelp();
+    process.exit(0);
+  }
+  if (command === '--list-targets') {
+    printTargets();
+    process.exit(0);
+  }
+  if (command !== 'install') {
+    console.error(`Unknown command: ${command}`);
+    printHelp();
+    process.exit(1);
+  }
+
+  try {
+    const code = await installCommand(rest);
+    process.exit(code);
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  parseInstallArgs,
+  normalizeTargets,
+};