create-neomutt-gmail 0.1.1

package/README.md

@@ -0,0 +1,265 @@
+# create-neomutt-gmail
+
+Interactive setup wizard for Neomutt + Gmail + OAuth2.0
+
+[![npm version](https://badge.fury.io/js/create-neomutt-gmail.svg)](https://www.npmjs.com/package/create-neomutt-gmail)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- ✅ **Interactive wizard** - Answer a few questions, get a working config
+- ✅ **Prerequisites check** - Verifies all dependencies before starting
+- ✅ **Safe operations** - Automatic backups, confirmation prompts
+- ✅ **Dry-run mode** - Preview changes without modifying files
+- ✅ **Automatic downloads** - Fetches OAuth2 script from official source
+- ✅ **Helpful guidance** - Clear next steps after installation
+
+## Quick Start
+
+```bash
+npx create-neomutt-gmail
+```
+
+That's it! Answer the questions and follow the on-screen instructions.
+
+## Prerequisites
+
+The wizard checks for these automatically, but you'll need:
+
+- **neomutt** - Email client
+- **python3** - For OAuth2 script
+- **gpg** - For token encryption
+
+On macOS:
+```bash
+brew install neomutt python3 gnupg
+```
+
+On Linux:
+```bash
+# Debian/Ubuntu
+sudo apt install neomutt python3 gnupg
+
+# Arch
+sudo pacman -S neomutt python gnupg
+```
+
+### GPG Key Setup
+
+If you don't have a GPG key yet:
+
+```bash
+gpg --full-generate-key
+```
+
+Choose:
+- RSA and RSA
+- 4096 bits
+- No expiration (or as preferred)
+- Enter your name and email
+
+## Usage
+
+### Standard Installation
+
+```bash
+npx create-neomutt-gmail
+```
+
+### Dry Run (Preview Only)
+
+```bash
+npx create-neomutt-gmail --dry-run
+```
+
+Shows what would be created without actually creating any files.
+
+### Skip Prerequisites Check
+
+```bash
+npx create-neomutt-gmail --skip-prereqs
+```
+
+Skips the dependency verification (not recommended).
+
+### Help
+
+```bash
+npx create-neomutt-gmail --help
+```
+
+## What It Does
+
+The wizard will:
+
+1. **Check prerequisites** - Verify neomutt, python3, gpg are installed
+2. **Ask configuration questions**:
+   - Gmail address
+   - Your name
+   - Preferred editor (nvim, vim, nano, emacs)
+   - Gmail language (Japanese or English)
+   - GPG key ID (optional)
+3. **Create directories**:
+   - `~/.config/mutt/`
+   - `~/.config/mutt/accounts/`
+   - `~/.local/etc/oauth-tokens/`
+   - `~/.cache/mutt/`
+4. **Generate config files**:
+   - `~/.config/mutt/muttrc`
+   - `~/.config/mutt/accounts/YOUR_EMAIL.muttrc`
+5. **Download OAuth script**:
+   - `~/.config/mutt/mutt_oauth2.py`
+6. **Display next steps** for Google Cloud Console setup
+
+## After Installation
+
+### Step 1: Google Cloud Console
+
+1. Visit https://console.cloud.google.com/
+2. Create a new project
+3. Enable Gmail API
+4. Configure OAuth consent screen (External)
+5. Add scope: `https://mail.google.com/`
+6. Add your email as test user
+7. Create OAuth client ID (Desktop application)
+8. Note Client ID and Client Secret
+
+### Step 2: Obtain OAuth Token
+
+Run the command shown by the wizard (it will look like this):
+
+```bash
+python3 ~/.config/mutt/mutt_oauth2.py \
+  --authorize \
+  --authflow localhostauthcode \
+  --encryption-pipe 'gpg --encrypt --recipient your@email.com' \
+  --client-id YOUR_CLIENT_ID.apps.googleusercontent.com \
+  --client-secret YOUR_CLIENT_SECRET \
+  --provider google \
+  --email your@email.com \
+  ~/.local/etc/oauth-tokens/gmail.tokens
+```
+
+### Step 3: Launch Neomutt
+
+```bash
+neomutt
+```
+
+## Keyboard Shortcuts
+
+Once Neomutt is running:
+
+| Key | Action |
+|-----|--------|
+| `gi` | Go to inbox |
+| `gt` | Go to trash |
+| `gs` | Go to sent mail |
+| `gd` | Go to drafts |
+| `m` | Compose new email |
+| `r` | Reply |
+| `q` | Quit |
+
+## Safety Features
+
+### Automatic Backups
+
+Existing config files are backed up with timestamps:
+```
+~/.config/mutt/muttrc.backup-2026-01-26T12-34-56-789Z
+```
+
+### Confirmation Prompts
+
+The wizard asks for confirmation before:
+- Overwriting existing configurations
+- Creating files
+- Proceeding with installation
+
+### Dry-Run Mode
+
+Preview all changes before applying them:
+```bash
+npx create-neomutt-gmail --dry-run
+```
+
+## File Permissions
+
+Created files have appropriate permissions:
+- Config files: `0o600` (owner read/write only)
+- OAuth script: `0o755` (owner rwx, others rx)
+
+## Troubleshooting
+
+### "Command not found: neomutt"
+
+Install neomutt:
+```bash
+brew install neomutt  # macOS
+sudo apt install neomutt  # Linux
+```
+
+### "No GPG keys found"
+
+Create a GPG key:
+```bash
+gpg --full-generate-key
+```
+
+### "Failed to download mutt_oauth2.py"
+
+Download manually:
+```bash
+curl -o ~/.config/mutt/mutt_oauth2.py \
+  https://raw.githubusercontent.com/neomutt/neomutt/main/contrib/oauth2/mutt_oauth2.py
+chmod +x ~/.config/mutt/mutt_oauth2.py
+```
+
+### OAuth Token Issues
+
+See the [detailed troubleshooting guide](https://github.com/a-lost-social-misfit/terminal-blog) for OAuth-specific issues.
+
+## Powered By
+
+This wizard uses:
+- [mutt-config-core](https://www.npmjs.com/package/mutt-config-core) - Configuration generation
+- [config-fs-utils](https://www.npmjs.com/package/config-fs-utils) - File system operations
+
+## Related Projects
+
+- [mutt-config-core](https://github.com/a-lost-social-misfit/mutt-config-core) - Core config generator
+- [config-fs-utils](https://github.com/a-lost-social-misfit/config-fs-utils) - FS utilities
+- [terminal-blog](https://github.com/a-lost-social-misfit/terminal-blog) - Detailed setup guide
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## ⚠️ Important Notice
+
+This tool modifies files in your home directory:
+- `~/.config/mutt/`
+- `~/.local/etc/oauth-tokens/`
+- `~/.cache/mutt/`
+
+Before running:
+1. ✅ Backup existing Neomutt configuration (if any)
+2. ✅ Review the code on GitHub
+3. ✅ Use `--dry-run` to preview changes
+
+The tool creates automatic backups, but it's your responsibility to:
+- Verify the configuration before use
+- Keep OAuth tokens secure
+- Review file permissions
+
+**No warranty is provided. Use at your own risk.**
+
+## License
+
+MIT © a-lost-social-misfit
+
+## Author
+
+Created by [a-lost-social-misfit](https://github.com/a-lost-social-misfit)
+
+Based on practical experience and lessons learned from setting up Neomutt with Gmail OAuth2.0 on macOS.

package/bin/cli.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+
+/**
+ * create-neomutt-gmail
+ * Interactive setup wizard for Neomutt + Gmail + OAuth2.0
+ */
+
+import { run } from "../src/index.js";
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const options = {
+  dryRun: args.includes("--dry-run"),
+  skipPrereqs: args.includes("--skip-prereqs"),
+  help: args.includes("--help") || args.includes("-h"),
+};
+
+// Show help
+if (options.help) {
+  console.log(`
+create-neomutt-gmail - Interactive setup wizard for Neomutt + Gmail
+
+Usage:
+  npx create-neomutt-gmail [options]
+
+Options:
+  --dry-run         Preview changes without creating files
+  --skip-prereqs    Skip prerequisites check
+  --help, -h        Show this help message
+
+Examples:
+  npx create-neomutt-gmail
+  npx create-neomutt-gmail --dry-run
+  
+For more information, visit:
+https://github.com/a-lost-social-misfit/create-neomutt-gmail
+`);
+  process.exit(0);
+}
+
+// Run the wizard
+run(options).catch((error) => {
+  console.error("\n❌ Error:", error.message);
+  if (process.env.DEBUG) {
+    console.error(error.stack);
+  }
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "create-neomutt-gmail",
+  "version": "0.1.1",
+  "description": "Interactive setup wizard for Neomutt + Gmail + OAuth2.0",
+  "main": "src/index.js",
+  "bin": {
+    "create-neomutt-gmail": "./bin/cli.js"
+  },
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "dev": "node bin/cli.js"
+  },
+  "keywords": [
+    "neomutt",
+    "gmail",
+    "oauth2",
+    "email",
+    "cli",
+    "setup",
+    "wizard",
+    "mutt"
+  ],
+  "author": "a-lost-social-misfit",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/a-lost-social-misfit/create-neomutt-gmail.git"
+  },
+  "bugs": {
+    "url": "https://github.com/a-lost-social-misfit/create-neomutt-gmail/issues"
+  },
+  "homepage": "https://github.com/a-lost-social-misfit/create-neomutt-gmail#readme",
+  "dependencies": {
+    "mutt-config-core": "^0.1.0",
+    "config-fs-utils": "^0.1.0",
+    "inquirer": "^13.2.1",
+    "chalk": "^5.6.2",
+    "ora": "^9.1.0",
+    "node-fetch": "^3.3.2"
+  },
+  "devDependencies": {
+    "jest": "^30.2.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "type": "module"
+}

package/src/display.js

@@ -0,0 +1,115 @@
+/**
+ * Display functions for user output
+ */
+
+import chalk from "chalk";
+import os from "os";
+
+/**
+ * Display next steps after installation
+ * @param {Object} answers - User configuration
+ */
+export function displayNextSteps(answers) {
+  console.log(chalk.bold("📖 Next Steps:\n"));
+
+  // Step 1: Google Cloud Console
+  console.log(chalk.bold("1. Setup Google Cloud Console"));
+  console.log(
+    "   Visit: " + chalk.cyan("https://console.cloud.google.com/") + "\n"
+  );
+  console.log(
+    "   " + chalk.dim("a.") + ' Create a new project (e.g., "neomutt-gmail")'
+  );
+  console.log("   " + chalk.dim("b.") + " Enable Gmail API");
+  console.log("   " + chalk.dim("c.") + " Configure OAuth consent screen:");
+  console.log("      • User Type: External");
+  console.log("      • Add scope: https://mail.google.com/");
+  console.log(`      • Add test user: ${chalk.cyan(answers.email)}`);
+  console.log(
+    "   " + chalk.dim("d.") + " Create OAuth client ID (Desktop application)"
+  );
+  console.log(
+    "   " + chalk.dim("e.") + " Note down Client ID and Client Secret\n"
+  );
+
+  // Step 2: Obtain OAuth token
+  console.log(chalk.bold("2. Obtain OAuth 2.0 token"));
+  console.log("   Run the following command:\n");
+
+  const command = `python3 ~/.config/mutt/mutt_oauth2.py \\
+  --authorize \\
+  --authflow localhostauthcode \\
+  --encryption-pipe 'gpg --encrypt --recipient ${answers.gpgKeyId || answers.email}' \\
+  --client-id YOUR_CLIENT_ID.apps.googleusercontent.com \\
+  --client-secret YOUR_CLIENT_SECRET \\
+  --provider google \\
+  --email ${answers.email} \\
+  ~/.local/etc/oauth-tokens/gmail.tokens`;
+
+  console.log(chalk.cyan(command) + "\n");
+  console.log(
+    chalk.dim(
+      "   Replace YOUR_CLIENT_ID and YOUR_CLIENT_SECRET with actual values"
+    )
+  );
+  console.log(chalk.dim("   You will be prompted for your GPG passphrase\n"));
+
+  // Step 3: Launch Neomutt
+  console.log(chalk.bold("3. Launch Neomutt"));
+  console.log("   " + chalk.cyan("neomutt") + "\n");
+
+  // Additional resources
+  console.log(chalk.dim("───────────────────────────────────\n"));
+  console.log("📚 For detailed instructions, visit:");
+  console.log("   https://github.com/a-lost-social-misfit/terminal-blog\n");
+  console.log("💬 Need help? Open an issue:");
+  console.log(
+    "   https://github.com/a-lost-social-misfit/create-neomutt-gmail/issues\n"
+  );
+
+  // Keyboard shortcuts reminder
+  console.log(chalk.bold("🎹 Neomutt Keyboard Shortcuts:\n"));
+  console.log("   " + chalk.cyan("gi") + " - Go to inbox");
+  console.log("   " + chalk.cyan("gt") + " - Go to trash");
+  console.log("   " + chalk.cyan("gs") + " - Go to sent mail");
+  console.log("   " + chalk.cyan("gd") + " - Go to drafts");
+  console.log("   " + chalk.cyan("m") + "  - Compose new email");
+  console.log("   " + chalk.cyan("r") + "  - Reply");
+  console.log("   " + chalk.cyan("q") + "  - Quit");
+}
+
+/**
+ * Display dry-run preview
+ * @param {Object} answers - User configuration
+ * @param {Object} paths - Configuration paths
+ * @param {Object} configs - Generated configurations
+ */
+export function displayDryRun(answers, paths, configs) {
+  const homeDir = os.homedir();
+
+  console.log(chalk.bold("📁 Directories to be created:\n"));
+  console.log(`  ${homeDir}/.config/mutt/`);
+  console.log(`  ${homeDir}/.config/mutt/accounts/`);
+  console.log(`  ${homeDir}/.local/etc/oauth-tokens/`);
+  console.log(`  ${homeDir}/.cache/mutt/headers/`);
+  console.log(`  ${homeDir}/.cache/mutt/bodies/`);
+
+  console.log(chalk.bold("\n📄 Files to be created:\n"));
+  console.log(`  ${homeDir}/${paths.accountMuttrc}`);
+  console.log(`  ${homeDir}/${paths.mainMuttrc}`);
+  console.log(`  ${homeDir}/.config/mutt/mutt_oauth2.py`);
+
+  console.log(chalk.bold("\n📝 Configuration preview:\n"));
+  console.log(chalk.dim("Account config (first 10 lines):"));
+  console.log(
+    chalk.dim(configs.accountMuttrc.split("\n").slice(0, 10).join("\n"))
+  );
+  console.log(chalk.dim("  ..."));
+
+  console.log(chalk.bold("\n⚙️  Settings:\n"));
+  console.log(`  Email: ${chalk.cyan(answers.email)}`);
+  console.log(`  Name: ${chalk.cyan(answers.realName)}`);
+  console.log(`  Editor: ${chalk.cyan(answers.editor)}`);
+  console.log(`  Locale: ${chalk.cyan(answers.locale)}`);
+  console.log(`  GPG Key: ${chalk.cyan(answers.gpgKeyId || answers.email)}`);
+}

package/src/download.js

@@ -0,0 +1,59 @@
+/**
+ * Download mutt_oauth2.py script
+ */
+
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+import fetch from "node-fetch";
+
+const MUTT_OAUTH2_URL =
+  "https://raw.githubusercontent.com/neomutt/neomutt/main/contrib/oauth2/mutt_oauth2.py";
+
+/**
+ * Download and install mutt_oauth2.py
+ * @returns {Promise<string>} Path to installed script
+ */
+export async function downloadMuttOAuth2() {
+  const targetPath = path.join(
+    os.homedir(),
+    ".config",
+    "mutt",
+    "mutt_oauth2.py"
+  );
+
+  // Check if already exists
+  try {
+    await fs.access(targetPath);
+    // File exists, skip download
+    return targetPath;
+  } catch {
+    // File doesn't exist, proceed with download
+  }
+
+  // Download
+  const response = await fetch(MUTT_OAUTH2_URL);
+  if (!response.ok) {
+    throw new Error(`Failed to download: ${response.statusText}`);
+  }
+
+  const content = await response.text();
+
+  // Basic validation - check if it looks like a Python script
+  if (
+    !content.includes("#!/usr/bin/env python") &&
+    !content.includes("import")
+  ) {
+    throw new Error(
+      "Downloaded file does not appear to be a valid Python script"
+    );
+  }
+
+  // Write file
+  await fs.writeFile(targetPath, content, "utf8");
+
+  // Make executable
+  await fs.chmod(targetPath, 0o755);
+
+  return targetPath;
+}

package/src/index.js

@@ -0,0 +1,167 @@
+/**
+ * Main application logic
+ */
+
+import { generateMuttConfigs, getConfigPaths } from "mutt-config-core";
+import {
+  setupStandardMuttDirs,
+  writeConfigFiles,
+  exists,
+} from "config-fs-utils";
+import inquirer from "inquirer";
+import chalk from "chalk";
+import ora from "ora";
+
+import { checkPrerequisites } from "./prerequisites.js";
+import { askQuestions } from "./questions.js";
+import { downloadMuttOAuth2 } from "./download.js";
+import { displayNextSteps, displayDryRun } from "./display.js";
+
+export async function run(options = {}) {
+  console.log(chalk.bold("\n🔧 Neomutt + Gmail Setup Wizard\n"));
+
+  // Prerequisites check
+  if (!options.skipPrereqs) {
+    console.log(chalk.blue("📋 Prerequisites Check"));
+    const prereqCheck = await checkPrerequisites();
+
+    if (!prereqCheck.allPassed) {
+      console.log(chalk.red("\n❌ Missing required dependencies."));
+      console.log("Please install them first and try again.\n");
+      process.exit(1);
+    }
+
+    console.log(chalk.dim("\n───────────────────────────────────\n"));
+  }
+
+  // Ask user questions
+  console.log(chalk.blue("📝 Configuration\n"));
+  const answers = await askQuestions();
+
+  console.log(chalk.dim("\n───────────────────────────────────\n"));
+
+  // Check for existing config and warn
+  const muttrcPath = `${process.env.HOME}/.config/mutt/muttrc`;
+  if (await exists(muttrcPath)) {
+    console.log(chalk.yellow("⚠️  Existing Neomutt configuration found."));
+    console.log(
+      chalk.yellow("   A backup will be created before overwriting.\n")
+    );
+
+    const { proceed } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "proceed",
+        message: "Continue with setup?",
+        default: true,
+      },
+    ]);
+
+    if (!proceed) {
+      console.log(chalk.dim("\nSetup cancelled."));
+      process.exit(0);
+    }
+
+    console.log();
+  }
+
+  // Dry run mode - show what would happen
+  if (options.dryRun) {
+    console.log(
+      chalk.bold.cyan("🔍 DRY RUN MODE - No files will be created\n")
+    );
+    const configs = generateMuttConfigs(answers);
+    const paths = getConfigPaths(answers.email);
+    displayDryRun(answers, paths, configs);
+    console.log(chalk.dim("\nRun without --dry-run to actually create files."));
+    return;
+  }
+
+  // Final confirmation
+  console.log(chalk.bold("📦 Ready to create:\n"));
+  console.log("  • Configuration directories");
+  console.log("  • Neomutt config files");
+  console.log("  • OAuth2 script\n");
+
+  const { finalConfirm } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "finalConfirm",
+      message: "Proceed with installation?",
+      default: true,
+    },
+  ]);
+
+  if (!finalConfirm) {
+    console.log(chalk.dim("\nSetup cancelled."));
+    process.exit(0);
+  }
+
+  console.log();
+
+  // Create directories
+  const spinner = ora("Creating directories...").start();
+  try {
+    const dirs = await setupStandardMuttDirs();
+    spinner.succeed("Directories created");
+
+    for (const [name, dirPath] of Object.entries(dirs)) {
+      console.log(chalk.green(`  ✓ ${dirPath}`));
+    }
+  } catch (error) {
+    spinner.fail("Failed to create directories");
+    throw error;
+  }
+
+  console.log();
+
+  // Generate and write config files
+  spinner.text = "Generating configuration files...";
+  spinner.start();
+
+  try {
+    const configs = generateMuttConfigs(answers);
+    const paths = getConfigPaths(answers.email);
+
+    const results = await writeConfigFiles({
+      [`~/${paths.accountMuttrc}`]: configs.accountMuttrc,
+      [`~/${paths.mainMuttrc}`]: configs.mainMuttrc,
+    });
+
+    spinner.succeed("Configuration files created");
+
+    for (const result of results) {
+      console.log(chalk.green(`  ✓ ${result.path}`));
+      if (result.backup) {
+        console.log(chalk.dim(`    (backup: ${result.backup})`));
+      }
+    }
+  } catch (error) {
+    spinner.fail("Failed to create config files");
+    throw error;
+  }
+
+  console.log();
+
+  // Download mutt_oauth2.py
+  spinner.text = "Downloading mutt_oauth2.py...";
+  spinner.start();
+
+  try {
+    const scriptPath = await downloadMuttOAuth2();
+    spinner.succeed("mutt_oauth2.py downloaded");
+    console.log(chalk.green(`  ✓ ${scriptPath}`));
+  } catch (error) {
+    spinner.fail("Failed to download mutt_oauth2.py");
+    console.log(chalk.yellow("\n⚠️  You can download it manually from:"));
+    console.log(
+      "   https://raw.githubusercontent.com/neomutt/neomutt/main/contrib/oauth2/mutt_oauth2.py"
+    );
+  }
+
+  console.log(chalk.dim("\n───────────────────────────────────\n"));
+
+  // Display next steps
+  console.log(chalk.bold.green("🎉 Configuration complete!\n"));
+  displayNextSteps(answers);
+}

package/src/prerequisites.js

@@ -0,0 +1,98 @@
+/**
+ * Prerequisites checking
+ */
+
+import { exec } from "child_process";
+import { promisify } from "util";
+import chalk from "chalk";
+
+const execAsync = promisify(exec);
+
+const REQUIRED_COMMANDS = [
+  {
+    cmd: "neomutt",
+    name: "neomutt",
+    required: true,
+    install: "brew install neomutt",
+  },
+  {
+    cmd: "python3",
+    name: "python3",
+    required: true,
+    install: "brew install python3",
+  },
+  {
+    cmd: "gpg",
+    name: "gpg",
+    required: true,
+    install: "brew install gnupg",
+  },
+];
+
+/**
+ * Check if a command exists in PATH
+ * @param {string} command - Command to check
+ * @returns {Promise<boolean>}
+ */
+async function checkCommand(command) {
+  try {
+    await execAsync(`which ${command}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if GPG has any keys configured
+ * @returns {Promise<boolean>}
+ */
+async function checkGPGKeys() {
+  try {
+    const { stdout } = await execAsync("gpg --list-secret-keys");
+    return stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check all prerequisites
+ * @returns {Promise<Object>} Check results
+ */
+export async function checkPrerequisites() {
+  const results = [];
+  let allPassed = true;
+
+  // Check required commands
+  for (const { cmd, name, required, install } of REQUIRED_COMMANDS) {
+    const found = await checkCommand(cmd);
+    results.push({ name, found, required, install });
+
+    if (found) {
+      console.log(chalk.green(`✓ ${name} found`));
+    } else {
+      console.log(chalk.red(`✗ ${name} not found`));
+      if (required) {
+        console.log(chalk.dim(`  Install: ${install}`));
+        allPassed = false;
+      }
+    }
+  }
+
+  // Check GPG keys
+  const hasGPGKeys = await checkGPGKeys();
+  if (hasGPGKeys) {
+    console.log(chalk.green("✓ GPG keys configured"));
+  } else {
+    console.log(chalk.yellow("⚠ No GPG keys found"));
+    console.log(
+      chalk.dim(
+        "  You will need to create a GPG key for OAuth token encryption"
+      )
+    );
+    console.log(chalk.dim("  Run: gpg --full-generate-key"));
+  }
+
+  return { results, allPassed, hasGPGKeys };
+}

package/src/questions.js

@@ -0,0 +1,68 @@
+/**
+ * User interaction prompts
+ */
+
+import inquirer from "inquirer";
+
+/**
+ * Ask user for configuration details
+ * @returns {Promise<Object>} User answers
+ */
+export async function askQuestions() {
+  const questions = [
+    {
+      type: "input",
+      name: "email",
+      message: "Gmail address:",
+      validate: (input) => {
+        const emailRegex = /^[^\s@]+@gmail\.com$/;
+        if (!emailRegex.test(input)) {
+          return "Please enter a valid Gmail address (e.g., user@gmail.com)";
+        }
+        return true;
+      },
+    },
+    {
+      type: "input",
+      name: "realName",
+      message: "Your name (for email headers):",
+      validate: (input) => {
+        if (input.trim().length === 0) {
+          return "Name is required";
+        }
+        return true;
+      },
+    },
+    {
+      type: "list",
+      name: "editor",
+      message: "Preferred text editor:",
+      choices: [
+        { name: "Neovim (nvim)", value: "nvim" },
+        { name: "Vim", value: "vim" },
+        { name: "Nano", value: "nano" },
+        { name: "Emacs", value: "emacs" },
+      ],
+      default: "nvim",
+    },
+    {
+      type: "list",
+      name: "locale",
+      message: "Gmail language setting:",
+      choices: [
+        { name: "日本語 (Japanese)", value: "ja" },
+        { name: "English", value: "en" },
+      ],
+      default: "ja",
+    },
+    {
+      type: "input",
+      name: "gpgKeyId",
+      message: "GPG key ID (press Enter to use email address):",
+      default: (answers) => answers.email,
+      when: () => true,
+    },
+  ];
+
+  return inquirer.prompt(questions);
+}