@bostonuniversity/buwp-local 0.2.0 → 0.4.0

package/.eslintrc.json

@@ -0,0 +1,15 @@
+{
+  "env": {
+    "es2022": true,
+    "node": true
+  },
+  "extends": "eslint:recommended",
+  "parserOptions": {
+    "ecmaVersion": "latest",
+    "sourceType": "module"
+  },
+  "rules": {
+    "no-unused-vars": ["error", { "argsIgnorePattern": "^_" }],
+    "no-console": "off"
+  }
+}

package/USAGE.md

@@ -10,14 +10,23 @@ npm install --save-dev @bostonuniversity/buwp-local
 
 ### 2. Initialize configuration
 
+**Interactive mode (recommended):**
 ```bash
-npx buwp-local config --init
+npx buwp-local init
 ```
 
+The interactive setup will guide you through:
+- Project name and type (plugin, theme, mu-plugin)
+- Hostname configuration
+- Port selection
+- Service options (Redis, S3, Shibboleth)
+- Debug settings
+
+**Non-interactive mode:**
 ```bash
-buwp-local config --init --plugin      # For plugins
-buwp-local config --init --mu-plugin   # For mu-plugins
-buwp-local config --init --theme       # For themes
+npx buwp-local config --init --plugin      # For plugins
+npx buwp-local config --init --mu-plugin   # For mu-plugins
+npx buwp-local config --init --theme       # For themes
 ```
 
 This creates `.buwp-local.json` in your project directory.
@@ -86,6 +95,23 @@ Open http://username.local or https://username.local in your browser.
 
 ## Commands
 
+### Initialize configuration
+```bash
+npx buwp-local init
+
+Options:
+  --no-interactive  Use non-interactive mode with defaults
+  --plugin          Non-interactive: initialize as plugin
+  --mu-plugin       Non-interactive: initialize as mu-plugin
+  --theme           Non-interactive: initialize as theme
+  -f, --force       Overwrite existing configuration
+```
+
+The `init` command provides an interactive setup experience with:
+- **Smart defaults** - Detects project type from files
+- **Real-time validation** - Validates inputs as you type
+- **Guided workflow** - Clear prompts for all configuration options
+
 ### Start environment
 ```bash
 npx buwp-local start [options]

package/bin/buwp-local.js

@@ -5,18 +5,30 @@
  * Main entry point for the BU WordPress Local development environment tool
  */
 
-const { Command } = require('commander');
-const chalk = require('chalk');
-const packageJson = require('../package.json');
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+// Get __dirname equivalent in ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Load package.json
+const packageJson = JSON.parse(
+  readFileSync(join(__dirname, '../package.json'), 'utf8')
+);
 
 // Import commands
-const startCommand = require('../lib/commands/start');
-const stopCommand = require('../lib/commands/stop');
-const destroyCommand = require('../lib/commands/destroy');
-const logsCommand = require('../lib/commands/logs');
-const wpCommand = require('../lib/commands/wp');
-const shellCommand = require('../lib/commands/shell');
-const configCommand = require('../lib/commands/config');
+import startCommand from '../lib/commands/start.js';
+import stopCommand from '../lib/commands/stop.js';
+import destroyCommand from '../lib/commands/destroy.js';
+import logsCommand from '../lib/commands/logs.js';
+import wpCommand from '../lib/commands/wp.js';
+import shellCommand from '../lib/commands/shell.js';
+import configCommand from '../lib/commands/config.js';
+import initCommand from '../lib/commands/init.js';
 
 const program = new Command();
 
@@ -67,6 +79,17 @@ program
   .option('--show', 'Show resolved configuration')
   .action(configCommand);
 
+// Init command (interactive configuration)
+program
+  .command('init')
+  .description('Initialize configuration interactively')
+  .option('--no-interactive', 'Use non-interactive mode with defaults')
+  .option('--plugin', 'Non-interactive: initialize as plugin')
+  .option('--mu-plugin', 'Non-interactive: initialize as mu-plugin')
+  .option('--theme', 'Non-interactive: initialize as theme')
+  .option('-f, --force', 'Overwrite existing configuration')
+  .action(initCommand);
+
 // WP-CLI proxy command
 program
   .command('wp <args...>')

package/lib/commands/config.js

@@ -2,8 +2,9 @@
  * Config command - Configuration management
  */
 
-const chalk = require('chalk');
-const { loadConfig, validateConfig, initConfig, CONFIG_FILE_NAME } = require('../config');
+import chalk from 'chalk';
+import path from 'path';
+import { loadConfig, validateConfig, initConfig, CONFIG_FILE_NAME } from '../config.js';
 
 async function configCommand(options) {
   try {
@@ -31,7 +32,6 @@ async function configCommand(options) {
         console.log(chalk.green(`✅ Created configuration file: ${configPath}\n`));
         
         if (initOptions.plugin || initOptions.muPlugin || initOptions.theme) {
-          const path = require('path');
           const projectName = path.basename(projectPath);
           const type = initOptions.plugin ? 'plugin' : initOptions.muPlugin ? 'mu-plugin' : 'theme';
           console.log(chalk.cyan(`Auto-configured mapping for ${type}: ${projectName}`));
@@ -128,4 +128,4 @@ function maskSensitiveData(config) {
   return masked;
 }
 
-module.exports = configCommand;
+export default configCommand;

package/lib/commands/destroy.js

@@ -2,12 +2,12 @@
  * Destroy command - Destroys the local WordPress environment (including volumes)
  */
 
-const chalk = require('chalk');
-const { execSync } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-const readline = require('readline');
-const { loadConfig } = require('../config');
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import readline from 'readline';
+import { loadConfig } from '../config.js';
 
 async function destroyCommand(options) {
   console.log(chalk.red('⚠️  DESTROY BU WordPress local environment\n'));
@@ -48,6 +48,7 @@ async function destroyCommand(options) {
     const composeDir = path.dirname(composePath);
     
     try {
+      // This is the actual docker compose down command that removes everything
       execSync(
         `docker compose -p ${projectName} -f ${composePath} down -v`,
         { 
@@ -93,4 +94,4 @@ function confirmDestroy(projectName) {
   });
 }
 
-module.exports = destroyCommand;
+export default destroyCommand;

package/lib/commands/init.js

@@ -0,0 +1,308 @@
+/**
+ * Init command - Interactive configuration initialization
+ */
+
+import prompts from 'prompts';
+import chalk from 'chalk';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { initConfig, CONFIG_FILE_NAME } from '../config.js';
+
+/**
+ * Detect project type from package.json or directory structure
+ * @param {string} projectPath - Path to project directory
+ * @returns {string|null} Detected project type or null
+ */
+function detectProjectType(projectPath) {
+  // Check package.json for hints
+  const packageJsonPath = path.join(projectPath, 'package.json');
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      
+      // Check keywords
+      if (pkg.keywords) {
+        if (pkg.keywords.includes('wordpress-plugin')) return 'plugin';
+        if (pkg.keywords.includes('wordpress-theme')) return 'theme';
+        if (pkg.keywords.includes('wordpress-muplugin')) return 'mu-plugin';
+      }
+      
+      // Check name patterns
+      if (pkg.name) {
+        if (pkg.name.includes('-plugin')) return 'plugin';
+        if (pkg.name.includes('-theme')) return 'theme';
+        if (pkg.name.includes('mu-')) return 'mu-plugin';
+      }
+    } catch (err) {
+      // Ignore errors reading package.json
+    }
+  }
+  
+  // Check for common WordPress files
+  if (fs.existsSync(path.join(projectPath, 'style.css'))) {
+    const styleContent = fs.readFileSync(path.join(projectPath, 'style.css'), 'utf8');
+    if (styleContent.includes('Theme Name:')) return 'theme';
+  }
+  
+  // Check for plugin header
+  const phpFiles = fs.readdirSync(projectPath).filter(f => f.endsWith('.php'));
+  for (const phpFile of phpFiles) {
+    const content = fs.readFileSync(path.join(projectPath, phpFile), 'utf8');
+    if (content.includes('Plugin Name:')) return 'plugin';
+  }
+  
+  return null; // Could not detect
+}
+
+/**
+ * Interactive initialization command
+ * @param {object} options - Command options
+ */
+async function initCommand(options) {
+  const projectPath = process.cwd();
+  const configPath = path.join(projectPath, CONFIG_FILE_NAME);
+  
+  const userName = os.userInfo().username;
+  
+  console.log(chalk.blue(`👋 Hello, ${userName}! Let's set up your WordPress local development environment.\n`));
+
+  // Check if config already exists
+  if (fs.existsSync(configPath) && !options.force) {
+    console.log(chalk.yellow(`⚠️  Configuration file already exists: ${configPath}`));
+    console.log(chalk.gray('Use --force to overwrite.\n'));
+    return;
+  }
+  
+  // Check if we should use interactive mode
+  const isInteractive = options.interactive !== false && process.stdin.isTTY;
+  
+  if (!isInteractive) {
+    // Fall back to non-interactive mode
+    console.log(chalk.gray('Non-interactive mode: using defaults\n'));
+    const initOptions = {};
+    if (options.plugin) initOptions.plugin = true;
+    if (options.muPlugin) initOptions.muPlugin = true;
+    if (options.theme) initOptions.theme = true;
+    
+    const configPath = initConfig(projectPath, initOptions);
+    console.log(chalk.green(`✅ Created configuration file: ${configPath}\n`));
+    return;
+  }
+  
+  // Interactive mode
+  console.log(chalk.blue('🚀 Interactive configuration setup\n'));
+  console.log(chalk.gray('Press Ctrl+C to cancel at any time\n'));
+  
+  const detectedName = path.basename(projectPath);
+  const detectedType = detectProjectType(projectPath);
+  
+  if (detectedType) {
+    console.log(chalk.cyan(`ℹ️  Detected project type: ${detectedType}\n`));
+  }
+  
+  // Determine default project type index
+  let defaultTypeIndex = 0;
+  if (detectedType === 'plugin') defaultTypeIndex = 0;
+  else if (detectedType === 'mu-plugin') defaultTypeIndex = 1;
+  else if (detectedType === 'theme') defaultTypeIndex = 2;
+  
+  const questions = [
+    {
+      type: 'text',
+      name: 'projectName',
+      message: 'Project name',
+      initial: detectedName,
+      validate: value => value.trim().length > 0 || 'Project name is required'
+    },
+    {
+      type: 'select',
+      name: 'projectType',
+      message: 'Project type',
+      choices: [
+        { title: 'Plugin', value: 'plugin', description: 'WordPress plugin development' },
+        { title: 'MU Plugin', value: 'mu-plugin', description: 'Must-use plugin development' },
+        { title: 'Theme', value: 'theme', description: 'WordPress theme development' },
+        { title: 'Sandbox', value: 'sandbox', description: 'Base WordPress environment (add code mappings later)' },
+        { title: 'Custom', value: 'custom', description: 'Custom mapping configuration' }
+      ],
+      initial: defaultTypeIndex
+    },
+    {
+      type: 'text',
+      name: 'hostname',
+      message: 'Hostname',
+      initial: (prev, values) => {
+        return `${userName}-${values.projectName}.local`;
+      },
+      validate: value => {
+        if (!value.trim()) return 'Hostname is required';
+        if (!value.includes('.')) return 'Hostname should include a domain (e.g., .local)';
+        return true;
+      }
+    },
+    {
+      type: 'text',
+      name: 'image',
+      message: 'WordPress Docker image',
+      initial: 'ghcr.io/bu-ist/bu-wp-docker-mod_shib:arm64-latest',
+      validate: value => {
+        if (!value.trim()) return 'Image name is required';
+        return true;
+      }
+    },
+    {
+      type: 'text',
+      name: 'httpPort',
+      message: 'HTTP port (default: 80)',
+      initial: '80',
+      validate: value => {
+        const port = parseInt(value);
+        if (isNaN(port) || port < 1 || port > 65535) return 'Port must be a number between 1 and 65535';
+        return true;
+      }
+    },
+    {
+      type: 'text',
+      name: 'httpsPort',
+      message: 'HTTPS port (default: 443)',
+      initial: '443',
+      validate: value => {
+        const port = parseInt(value);
+        if (isNaN(port) || port < 1 || port > 65535) return 'Port must be a number between 1 and 65535';
+        return true;
+      }
+    },
+    {
+      type: 'text',
+      name: 'dbPort',
+      message: 'Database port (default: 3306)',
+      initial: '3306',
+      validate: value => {
+        const port = parseInt(value);
+        if (isNaN(port) || port < 1 || port > 65535) return 'Port must be a number between 1 and 65535';
+        return true;
+      }
+    },
+    {
+      type: 'confirm',
+      name: 'redis',
+      message: 'Enable Redis?',
+      initial: true
+    },
+    {
+      type: 'confirm',
+      name: 's3proxy',
+      message: 'Enable S3 proxy?',
+      initial: true
+    },
+    {
+      type: 'confirm',
+      name: 'shibboleth',
+      message: 'Enable Shibboleth?',
+      initial: true
+    },
+    {
+      type: 'confirm',
+      name: 'xdebug',
+      message: 'Enable Xdebug by default?',
+      initial: false
+    }
+  ];
+  
+  const answers = await prompts(questions, {
+    onCancel: () => {
+      console.log(chalk.yellow('\n⚠️  Setup cancelled\n'));
+      process.exit(0);
+    }
+  });
+  
+  // Build configuration object
+  const config = {
+    projectName: answers.projectName,
+    image: answers.image,
+    hostname: answers.hostname,
+    multisite: true,
+    services: {
+      redis: answers.redis || false,
+      s3proxy: answers.s3proxy || false,
+      shibboleth: answers.shibboleth || false
+    },
+    ports: {
+      http: parseInt(answers.httpPort),
+      https: parseInt(answers.httpsPort),
+      db: parseInt(answers.dbPort),
+      redis: 6379
+    },
+    mappings: [],
+    env: {
+      WP_DEBUG: true,
+      XDEBUG: answers.xdebug || false
+    }
+  };
+  
+  // Add mapping based on project type
+  if (answers.projectType === 'plugin') {
+    config.mappings.push({
+      local: './',
+      container: `/var/www/html/wp-content/plugins/${answers.projectName}`
+    });
+  } else if (answers.projectType === 'mu-plugin') {
+    config.mappings.push({
+      local: './',
+      container: `/var/www/html/wp-content/mu-plugins/${answers.projectName}`
+    });
+  } else if (answers.projectType === 'theme') {
+    config.mappings.push({
+      local: './',
+      container: `/var/www/html/wp-content/themes/${answers.projectName}`
+    });
+  } else if (answers.projectType === 'sandbox') {
+    // Sandbox type: no initial mappings
+    // User can add mappings manually to config.mappings array
+  } else {
+    // Custom type
+    config.mappings.push({
+      local: './',
+      container: '/var/www/html/wp-content/plugins/my-plugin',
+      comment: 'Customize this mapping for your project'
+    });
+  }
+  
+  // Write configuration file
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+  
+  console.log(chalk.green(`\n✅ Created configuration file: ${configPath}\n`));
+  
+  // Show summary
+  console.log(chalk.cyan('📋 Configuration summary:'));
+  console.log(chalk.gray(`  Project: ${answers.projectName}`));
+  console.log(chalk.gray(`  Type: ${answers.projectType}`));
+  console.log(chalk.gray(`  Hostname: ${answers.hostname}`));
+  console.log(chalk.gray(`  Image: ${answers.image}`));
+  console.log(chalk.gray(`  HTTP port: ${answers.httpPort}`));
+  console.log(chalk.gray(`  HTTPS port: ${answers.httpsPort}`));
+  console.log(chalk.gray(`  Services: ${[
+    answers.redis && 'Redis',
+    answers.s3proxy && 'S3',
+    answers.shibboleth && 'Shibboleth'
+  ].filter(Boolean).join(', ') || 'None'}\n`));
+  
+  // Show next steps
+  console.log(chalk.cyan('📝 Next steps:'));
+  console.log(chalk.gray('  1. Create .env.local with your credentials'));
+  console.log(chalk.gray(`  2. Add to /etc/hosts: 127.0.0.1 ${answers.hostname}`));
+  
+  if (answers.projectType === 'sandbox') {
+    console.log(chalk.gray('  3. Edit .buwp-local.json and add volume mappings to the mappings array'));
+    console.log(chalk.gray('  4. Run: buwp-local start'));
+    console.log(chalk.gray(`\n  Example mapping for .buwp-local.json mappings array:`));
+    console.log(chalk.gray(`  { "local": "/path/to/plugin", "container": "/var/www/html/wp-content/plugins/my-plugin" }`));
+  } else {
+    console.log(chalk.gray('  3. Run: buwp-local start'));
+  }
+  
+  console.log(chalk.gray(`\n  Then access: https://${answers.hostname}\n`));
+}
+
+export default initCommand;

package/lib/commands/logs.js

@@ -2,11 +2,11 @@
  * Logs command - View logs from the WordPress environment
  */
 
-const chalk = require('chalk');
-const { execSync } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-const { loadConfig } = require('../config');
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import { loadConfig } from '../config.js';
 
 async function logsCommand(options) {
   console.log(chalk.blue('📋 Viewing logs...\n'));
@@ -63,4 +63,4 @@ async function logsCommand(options) {
   }
 }
 
-module.exports = logsCommand;
+export default logsCommand;

package/lib/commands/shell.js

@@ -2,13 +2,13 @@
  * Shell command - Open an interactive bash shell in the WordPress container
  */
 
-const chalk = require('chalk');
-const { spawnSync } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-const { loadConfig } = require('../config');
+import chalk from 'chalk';
+import { spawnSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import { loadConfig } from '../config.js';
 
-async function shellCommand(options) {
+async function shellCommand(_options) {
   console.log(chalk.blue('🐚 Opening interactive shell...\n'));
 
   try {
@@ -68,4 +68,4 @@ async function shellCommand(options) {
   }
 }
 
-module.exports = shellCommand;
+export default shellCommand;

package/lib/commands/start.js

@@ -2,11 +2,11 @@
  * Start command - Starts the local WordPress environment
  */
 
-const chalk = require('chalk');
-const { execSync } = require('child_process');
-const path = require('path');
-const { loadConfig, validateConfig } = require('../config');
-const { generateComposeFile } = require('../compose-generator');
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import path from 'path';
+import { loadConfig, validateConfig } from '../config.js';
+import { generateComposeFile } from '../compose-generator.js';
 
 async function startCommand(options) {
   console.log(chalk.blue('🚀 Starting BU WordPress local environment...\n'));
@@ -95,4 +95,4 @@ async function startCommand(options) {
   }
 }
 
-module.exports = startCommand;
+export default startCommand;

package/lib/commands/stop.js

@@ -2,11 +2,11 @@
  * Stop command - Stops the local WordPress environment
  */
 
-const chalk = require('chalk');
-const { execSync } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-const { loadConfig } = require('../config');
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import { loadConfig } from '../config.js';
 
 async function stopCommand() {
   console.log(chalk.blue('🛑 Stopping BU WordPress local environment...\n'));
@@ -59,4 +59,4 @@ async function stopCommand() {
   }
 }
 
-module.exports = stopCommand;
+export default stopCommand;

package/lib/commands/wp.js

@@ -2,13 +2,13 @@
  * WP-CLI proxy command - Execute WP-CLI commands in the WordPress container
  */
 
-const chalk = require('chalk');
-const { execSync } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-const { loadConfig } = require('../config');
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import { loadConfig } from '../config.js';
 
-async function wpCommand(args, options) {
+async function wpCommand(args, _options) {
   try {
     const projectPath = process.cwd();
     const composePath = path.join(projectPath, '.buwp-local', 'docker-compose.yml');
@@ -54,4 +54,4 @@ async function wpCommand(args, options) {
   }
 }
 
-module.exports = wpCommand;
+export default wpCommand;

package/lib/compose-generator.js

@@ -3,10 +3,9 @@
  * Generates docker-compose.yml from configuration using js-yaml
  */
 
-const yaml = require('js-yaml');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
+import yaml from 'js-yaml';
+import fs from 'fs';
+import path from 'path';
 
 /**
  * Generate docker-compose configuration from buwp-local config
@@ -272,7 +271,7 @@ function generateComposeFile(config, projectPath = process.cwd()) {
   return writeComposeFile(composeConfig, composePath);
 }
 
-module.exports = {
+export {
   generateComposeConfig,
   generateComposeFile,
   writeComposeFile

package/lib/config.js

@@ -3,9 +3,10 @@
  * Handles loading, validating, and merging configuration from various sources
  */
 
-const fs = require('fs');
-const path = require('path');
-const chalk = require('chalk');
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import dotenv from 'dotenv';
 
 const CONFIG_FILE_NAME = '.buwp-local.json';
 const ENV_FILE_NAME = '.env.local';
@@ -58,7 +59,7 @@ function loadConfig(projectPath = process.cwd()) {
   // Load .env.local if it exists
   if (fs.existsSync(envPath)) {
     try {
-      require('dotenv').config({ path: envPath });
+      dotenv.config({ path: envPath });
       envVars = extractEnvVars();
     } catch (err) {
       console.warn(chalk.yellow(`Warning: Failed to load ${ENV_FILE_NAME}: ${err.message}`));
@@ -282,7 +283,7 @@ function sanitizeProjectName(name) {
     .replace(/^-+|-+$/g, ''); // Remove leading/trailing dashes
 }
 
-module.exports = {
+export {
   loadConfig,
   validateConfig,
   initConfig,

package/lib/index.js

@@ -3,21 +3,14 @@
  * Main library exports
  */
 
-const config = require('./config');
-const composeGenerator = require('./compose-generator');
+import * as config from './config.js';
+import * as composeGenerator from './compose-generator.js';
 
-module.exports = {
-  // Configuration
-  loadConfig: config.loadConfig,
-  validateConfig: config.validateConfig,
-  initConfig: config.initConfig,
-  
-  // Docker Compose generation
-  generateComposeConfig: composeGenerator.generateComposeConfig,
-  generateComposeFile: composeGenerator.generateComposeFile,
-  
-  // Constants
-  CONFIG_FILE_NAME: config.CONFIG_FILE_NAME,
-  ENV_FILE_NAME: config.ENV_FILE_NAME,
-  DEFAULT_CONFIG: config.DEFAULT_CONFIG
-};
+export const loadConfig = config.loadConfig;
+export const validateConfig = config.validateConfig;
+export const initConfig = config.initConfig;
+export const generateComposeConfig = composeGenerator.generateComposeConfig;
+export const generateComposeFile = composeGenerator.generateComposeFile;
+export const CONFIG_FILE_NAME = config.CONFIG_FILE_NAME;
+export const ENV_FILE_NAME = config.ENV_FILE_NAME;
+export const DEFAULT_CONFIG = config.DEFAULT_CONFIG;

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@bostonuniversity/buwp-local",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Local WordPress development environment for Boston University projects",
+  "type": "module",
   "main": "lib/index.js",
   "bin": {
     "buwp-local": "./bin/buwp-local.js"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "dev": "node bin/buwp-local.js",
+    "buwp-local": "node bin/buwp-local.js",
     "lint": "eslint ."
   },
   "keywords": [
@@ -21,15 +22,17 @@
   "author": "Boston University",
   "license": "ISC",
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=18.0.0"
   },
   "dependencies": {
     "js-yaml": "^4.1.0",
     "chalk": "^4.1.2",
     "commander": "^11.0.0",
-    "dotenv": "^16.3.1"
+    "dotenv": "^16.3.1",
+    "prompts": "^2.4.2"
   },
   "devDependencies": {
+    "@types/prompts": "^2.4.9",
     "eslint": "^8.50.0"
   }
 }

package/.buwp-local.json

@@ -1,27 +0,0 @@
-{
-  "image": "ghcr.io/bu-ist/bu-wp-docker-mod_shib:arm64-latest",
-  "hostname": "jaydub.local",
-  "multisite": true,
-  "services": {
-    "redis": true,
-    "s3proxy": true,
-    "shibboleth": true
-  },
-  "ports": {
-    "http": 80,
-    "https": 443,
-    "db": 3306,
-    "redis": 6379
-  },
-  "mappings": [
-    {
-      "local": "./",
-      "container": "/var/www/html/wp-content/plugins/my-plugin",
-      "comment": "Map current directory to a plugin location"
-    }
-  ],
-  "env": {
-    "WP_DEBUG": false,
-    "XDEBUG": true
-  }
-}

package/SHARED_ENVIRONMENT_EXAMPLES.md

@@ -1,578 +0,0 @@
-# Shared Environment - Practical Examples
-
-## Example 1: Team Integration Sandbox
-
-### Scenario
-A team of 4 developers working on BU's WordPress site needs a shared local environment with:
-- Custom theme (responsive-framework)
-- Navigation plugin (bu-navigation)  
-- Analytics plugin (bu-custom-analytics)
-- Slideshow plugin (bu-slideshow)
-
-### Setup
-
-**Step 1: Create Primary Configuration Repo**
-```bash
-mkdir -p ~/projects/bu-team-sandbox
-cd ~/projects/bu-team-sandbox
-
-# Initialize
-buwp-local config --init
-
-# Edit .buwp-local.json:
-{
-  "projectName": "bu-team-sandbox",
-  "hostname": "buteam.local",
-  "multisite": true,
-  "services": {
-    "redis": true,
-    "s3proxy": true,
-    "shibboleth": true
-  },
-  "ports": {
-    "http": 80,
-    "https": 443,
-    "db": 3306,
-    "redis": 6379
-  },
-  "mappings": [],
-  "env": {
-    "WP_DEBUG": true,
-    "WP_DEBUG_LOG": true,
-    "XDEBUG": false
-  }
-}
-
-# Create .env.local with credentials
-# Start environment
-buwp-local start
-```
-
-**Step 2: Each Developer Adds Their Repo**
-
-**Developer 1 - Theme:**
-```bash
-cd ~/projects/responsive-framework
-buwp-local config --init --theme
-
-# Edit .buwp-local.json to join shared sandbox:
-{
-  "projectName": "bu-team-sandbox",  # SHARED!
-  "hostname": "buteam.local",
-  "multisite": true,
-  "services": {
-    "redis": true,
-    "s3proxy": true,
-    "shibboleth": true
-  },
-  "ports": {
-    "http": 80,
-    "https": 443,
-    "db": 3306,
-    "redis": 6379
-  },
-  "mappings": [
-    {
-      "local": "./",
-      "container": "/var/www/html/wp-content/themes/responsive-framework"
-    }
-  ],
-  "env": {
-    "WP_DEBUG": true
-  }
-}
-
-# Symlink shared credentials
-ln -s ~/projects/bu-team-sandbox/.env.local .env.local
-
-# Add theme to shared environment
-buwp-local start
-```
-
-**Developer 2 - Navigation Plugin:**
-```bash
-cd ~/projects/bu-navigation
-buwp-local config --init --plugin
-
-# Edit .buwp-local.json (same projectName):
-{
-  "projectName": "bu-team-sandbox",
-  "hostname": "buteam.local",
-  # ... same ports/services ...
-  "mappings": [
-    {
-      "local": "./",
-      "container": "/var/www/html/wp-content/plugins/bu-navigation"
-    }
-  ]
-}
-
-ln -s ~/projects/bu-team-sandbox/.env.local .env.local
-buwp-local start
-```
-
-**Developers 3 & 4 repeat for their plugins...**
-
-**Result:**
-- All 4 developers access http://buteam.local
-- All plugins and theme are active
-- Shared database with realistic test data
-- Each developer's file changes are live
-
----
-
-## Example 2: Solo Developer - Isolated + Shared
-
-### Scenario
-One developer working on `bu-custom-analytics` needs:
-- **Isolated environment** for feature development
-- **Shared environment** for integration testing with other plugins
-
-### Setup
-
-**Isolated Configuration** (`.buwp-local.json`):
-```json
-{
-  "projectName": "bu-custom-analytics",
-  "hostname": "analytics.local",
-  "multisite": true,
-  "services": {
-    "redis": true,
-    "s3proxy": false,
-    "shibboleth": false
-  },
-  "ports": {
-    "http": 80,
-    "https": 443,
-    "db": 3306,
-    "redis": 6379
-  },
-  "mappings": [
-    {
-      "local": "./",
-      "container": "/var/www/html/wp-content/plugins/bu-custom-analytics"
-    }
-  ],
-  "env": {
-    "WP_DEBUG": true,
-    "XDEBUG": true
-  }
-}
-```
-
-**Shared Configuration** (`.buwp-local.shared.json`):
-```json
-{
-  "projectName": "bu-integration",
-  "hostname": "buint.local",
-  "multisite": true,
-  "services": {
-    "redis": true,
-    "s3proxy": true,
-    "shibboleth": true
-  },
-  "ports": {
-    "http": 8080,
-    "https": 8443,
-    "db": 3307,
-    "redis": 6380
-  },
-  "mappings": [
-    {
-      "local": "./",
-      "container": "/var/www/html/wp-content/plugins/bu-custom-analytics"
-    }
-  ],
-  "env": {
-    "WP_DEBUG": true,
-    "XDEBUG": false
-  }
-}
-```
-
-### Workflow
-
-**Morning - Feature Development (Isolated):**
-```bash
-cd ~/projects/bu-custom-analytics
-
-# Use isolated config (default)
-buwp-local start
-
-# Develop at http://analytics.local
-# Fast, isolated, clean environment
-# Debug with Xdebug enabled
-```
-
-**Afternoon - Integration Testing (Shared):**
-```bash
-cd ~/projects/bu-custom-analytics
-
-# Stop isolated
-buwp-local stop
-
-# Switch to shared config
-cp .buwp-local.shared.json .buwp-local.json
-
-# Join shared integration environment
-buwp-local start
-
-# Test at http://buint.local:8080
-# Now running with other plugins/theme
-# Test interactions and integration points
-```
-
-**End of Day - Back to Isolated:**
-```bash
-# Restore isolated config
-git checkout .buwp-local.json
-
-# Back to isolated for tomorrow
-buwp-local destroy  # Clean up shared
-buwp-local start    # Start fresh isolated
-```
-
----
-
-## Example 3: Multi-Environment Matrix
-
-### Scenario
-Testing plugin compatibility across different configurations:
-- Modern stack (latest everything)
-- Legacy stack (older versions)
-- Production replica
-
-### Setup
-
-**Create 3 Separate Environments:**
-
-**Environment 1: Modern Stack**
-```bash
-cd ~/projects/bu-custom-analytics
-
-# .buwp-local.modern.json:
-{
-  "projectName": "modern-stack",
-  "hostname": "modern.local",
-  "image": "ghcr.io/bu-ist/bu-wp-docker-mod_shib:arm64-latest",
-  # ... modern settings ...
-}
-
-cp .buwp-local.modern.json .buwp-local.json
-buwp-local start
-# Test at http://modern.local
-```
-
-**Environment 2: Legacy Stack**
-```bash
-# .buwp-local.legacy.json:
-{
-  "projectName": "legacy-stack",
-  "hostname": "legacy.local",
-  "image": "ghcr.io/bu-ist/bu-wp-docker-mod_shib:legacy-tag",
-  "ports": {
-    "http": 8081,
-    "db": 3307
-  }
-  # ... legacy settings ...
-}
-
-cp .buwp-local.legacy.json .buwp-local.json
-buwp-local start
-# Test at http://legacy.local:8081
-```
-
-**Environment 3: Production Replica**
-```bash
-# .buwp-local.prod.json:
-{
-  "projectName": "prod-replica",
-  "hostname": "prodlocal.local",
-  "ports": {
-    "http": 8082,
-    "db": 3308
-  }
-  # ... production-like settings ...
-}
-
-cp .buwp-local.prod.json .buwp-local.json
-buwp-local start
-# Test at http://prodlocal.local:8082
-```
-
-**Result:**
-- All 3 environments running simultaneously
-- Same plugin code in all 3
-- Different WordPress/PHP versions
-- Test compatibility across configurations
-
----
-
-## Example 4: Department-Wide Shared Sandbox
-
-### Scenario
-Marketing department (10 people) needs shared sandbox with:
-- Content editors
-- Designers  
-- Developers
-- QA testers
-
-### Setup
-
-**Central Configuration Repository:**
-```bash
-# Shared repo that everyone clones
-git clone https://github.com/bu-ist/bu-marketing-sandbox.git
-cd bu-marketing-sandbox
-
-# .buwp-local.json:
-{
-  "projectName": "bu-marketing",
-  "hostname": "marketing.local",
-  "multisite": true,
-  "services": {
-    "redis": true,
-    "s3proxy": true,
-    "shibboleth": true
-  },
-  "ports": {
-    "http": 80,
-    "https": 443,
-    "db": 3306,
-    "redis": 6379
-  },
-  "mappings": [
-    {
-      "local": "../responsive-framework",
-      "container": "/var/www/html/wp-content/themes/responsive-framework"
-    },
-    {
-      "local": "../bu-slideshow",
-      "container": "/var/www/html/wp-content/plugins/bu-slideshow"
-    },
-    {
-      "local": "../bu-analytics",
-      "container": "/var/www/html/wp-content/plugins/bu-analytics"
-    }
-  ],
-  "env": {
-    "WP_DEBUG": false  # Production-like for QA
-  }
-}
-
-# .env.local (shared credentials via 1Password/LastPass)
-# Includes test user accounts for all team members
-```
-
-**Each Team Member:**
-```bash
-# Clone central config
-git clone https://github.com/bu-ist/bu-marketing-sandbox.git ~/projects/bu-marketing-sandbox
-
-# Clone the repos to develop
-cd ~/projects
-git clone https://github.com/bu-ist/responsive-framework.git
-git clone https://github.com/bu-ist/bu-slideshow.git
-git clone https://github.com/bu-ist/bu-analytics.git
-
-# Start shared environment
-cd ~/projects/bu-marketing-sandbox
-# Add .env.local with shared credentials
-buwp-local start
-
-# Access http://marketing.local
-# All team members work in same environment
-```
-
-**Benefits:**
-- Designers see live changes to theme
-- Developers see plugin interactions
-- Content editors have realistic environment
-- QA tests actual configuration
-- Everyone shares same database with test content
-
----
-
-## Example 5: Feature Branch Testing
-
-### Scenario  
-Test a feature branch alongside main branch:
-- `main` branch in production-like environment
-- `feature/new-ui` branch in test environment
-
-### Setup
-
-**Main Branch Environment:**
-```bash
-cd ~/projects/bu-custom-analytics
-git checkout main
-
-# .buwp-local.json (default):
-{
-  "projectName": "bu-analytics-main",
-  "hostname": "analytics-main.local",
-  "ports": {
-    "http": 80,
-    "db": 3306
-  },
-  "mappings": [
-    {
-      "local": "./",
-      "container": "/var/www/html/wp-content/plugins/bu-custom-analytics"
-    }
-  ]
-}
-
-buwp-local start
-# Test main at http://analytics-main.local
-```
-
-**Feature Branch Environment:**
-```bash
-cd ~/projects/bu-custom-analytics
-git checkout feature/new-ui
-
-# Change projectName in .buwp-local.json:
-{
-  "projectName": "bu-analytics-feature",
-  "hostname": "analytics-feature.local",
-  "ports": {
-    "http": 8080,
-    "db": 3307
-  },
-  "mappings": [
-    {
-      "local": "./",
-      "container": "/var/www/html/wp-content/plugins/bu-custom-analytics"
-    }
-  ]
-}
-
-buwp-local start
-# Test feature at http://analytics-feature.local:8080
-```
-
-**Result:**
-- Both branches running simultaneously
-- Compare behavior side-by-side
-- Separate databases for each
-- No branch switching needed
-
----
-
-## Tips for Shared Environments
-
-### 1. Use Configuration Management
-```bash
-# Store configs in version control
-~/projects/
-├── bu-team-sandbox/           # Primary config repo
-│   ├── .buwp-local.json
-│   ├── .env.local.example
-│   └── README.md
-├── plugin-a/
-│   ├── .buwp-local.json       # Points to shared
-│   └── .env.local -> ../bu-team-sandbox/.env.local
-└── plugin-b/
-    ├── .buwp-local.json       # Points to shared
-    └── .env.local -> ../bu-team-sandbox/.env.local
-```
-
-### 2. Document Your Shared Environments
-Create a team wiki page:
-```markdown
-# Team Shared Environments
-
-## bu-team-sandbox
-- **URL:** http://buteam.local
-- **Purpose:** Integration testing
-- **Includes:** theme + all plugins
-- **Managed by:** @teamlead
-- **Config repo:** github.com/bu-ist/bu-team-sandbox
-
-## bu-staging-replica
-- **URL:** http://bustaging.local:8080  
-- **Purpose:** Pre-production testing
-- **Includes:** Production plugins only
-- **Managed by:** @qa-lead
-```
-
-### 3. Use Consistent Naming
-```bash
-# Good naming convention:
-bu-team-sandbox      # Team shared environment
-bu-integration       # Integration testing
-bu-staging-replica   # Staging mirror
-bu-prod-replica      # Production mirror
-
-# Avoid:
-sandbox
-test
-local
-dev
-```
-
-### 4. Regular Cleanup
-```bash
-# Weekly: Clean shared environments
-buwp-local destroy
-buwp-local start
-# Fresh start with clean database
-```
-
-### 5. Backup Shared Databases
-```bash
-# Before major changes:
-docker exec bu-team-sandbox-db-1 mysqldump -u wordpress -ppassword wordpress > backup-$(date +%Y%m%d).sql
-
-# Restore if needed:
-docker exec -i bu-team-sandbox-db-1 mysql -u wordpress -ppassword wordpress < backup-20251110.sql
-```
-
----
-
-## Troubleshooting Common Issues
-
-### Issue: "Port already in use"
-**Cause:** Another shared environment using same ports  
-**Solution:** Use different ports in shared config:
-```json
-{
-  "ports": {
-    "http": 8081,
-    "db": 3307
-  }
-}
-```
-
-### Issue: "My changes don't appear"
-**Cause:** Wrong repo's mapping is active  
-**Solution:** Check which repo last ran `start`:
-```bash
-docker compose -p bu-team-sandbox ps
-# See which volumes are mounted
-```
-
-### Issue: "Database has wrong data"
-**Cause:** Another developer made changes  
-**Solution:** Communicate or use separate environments
-
-### Issue: "Config out of sync"
-**Cause:** Repos have different settings  
-**Solution:** Use symlinks or central config repo
-
----
-
-## Summary
-
-Shared environments enable:
-- ✅ Team collaboration on integrated stack
-- ✅ Integration testing without deploy
-- ✅ Multiple development strategies
-- ✅ Flexible workflows (solo + team)
-- ✅ Realistic production-like testing
-
-Use the right tool for the job:
-- **Isolated** = Solo development, fast iteration
-- **Shared** = Integration, team collaboration
-- **Both** = Maximum flexibility