@fredlackey/devutils 0.0.19 → 0.1.0

package/src/commands/config/import.js

@@ -0,0 +1,308 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const DEVUTILS_DIR = path.join(os.homedir(), '.devutils');
+const CONFIG_FILE = path.join(DEVUTILS_DIR, 'config.json');
+
+const meta = {
+  description: 'Pull config from remote backup and apply locally, or import from a local file.',
+  arguments: [],
+  flags: [
+    { name: 'file', type: 'string', description: 'Import from a local file instead of remote backup' },
+    { name: 'profile', type: 'string', description: 'Import a specific profile from the backup' }
+  ]
+};
+
+/**
+ * The config file keys and their mapping in the export bundle.
+ * Each entry maps a local filename to the bundle property name.
+ */
+const FILES_TO_IMPORT = {
+  'config.json': 'config',
+  'aliases.json': 'aliases',
+  'ai.json': 'ai',
+  'plugins.json': 'plugins'
+};
+
+/**
+ * Read a config file from ~/.devutils/ if it exists.
+ * Returns the parsed content, or null if the file is missing or invalid JSON.
+ *
+ * @param {string} filename - The filename to read (e.g., 'config.json').
+ * @returns {object|null} The parsed JSON content, or null.
+ */
+function readConfigFile(filename) {
+  const filePath = path.join(DEVUTILS_DIR, filename);
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write imported config data to ~/.devutils/.
+ * Only writes files that have data (skips null entries).
+ *
+ * @param {object} bundle - The import bundle with config, aliases, ai, plugins keys.
+ * @returns {number} The number of files written.
+ */
+function writeImportedFiles(bundle) {
+  fs.mkdirSync(DEVUTILS_DIR, { recursive: true });
+
+  let imported = 0;
+  for (const [filename, key] of Object.entries(FILES_TO_IMPORT)) {
+    const data = bundle[key];
+    if (data) {
+      fs.writeFileSync(
+        path.join(DEVUTILS_DIR, filename),
+        JSON.stringify(data, null, 2) + '\n'
+      );
+      imported++;
+    }
+  }
+
+  return imported;
+}
+
+/**
+ * Write the sync timestamp after a successful import.
+ *
+ * @param {string} profileName - The profile that was imported.
+ */
+function writeSyncTimestamp(profileName) {
+  const syncPath = path.join(DEVUTILS_DIR, 'sync.json');
+  const syncData = {
+    lastSync: new Date().toISOString(),
+    direction: 'import',
+    profile: profileName
+  };
+  fs.writeFileSync(syncPath, JSON.stringify(syncData, null, 2) + '\n');
+}
+
+/**
+ * Print the next-steps reminder after a successful import.
+ *
+ * @param {object} context - CLI context (output).
+ */
+function printNextSteps(context) {
+  context.output.info('');
+  context.output.info('Next steps:');
+  context.output.info('  1. Run "dev alias sync" to rebuild alias wrapper scripts');
+  context.output.info('  2. Run "dev status" to verify your configuration');
+}
+
+/**
+ * Run the config import command.
+ * Supports two modes:
+ * - File mode (--file): Reads a JSON export file from disk and writes config locally.
+ * - Remote mode (default): Pulls config from a GitHub repo or gist based on backup settings.
+ *
+ * @param {object} args - Parsed CLI arguments (positional, flags).
+ * @param {object} context - CLI context (output, prompt, errors).
+ */
+async function run(args, context) {
+  const github = require('../../lib/github');
+
+  // --- File import mode ---
+  if (args.flags.file) {
+    const filePath = path.resolve(args.flags.file);
+    if (!fs.existsSync(filePath)) {
+      context.output.error(`File not found: ${filePath}`);
+      return;
+    }
+
+    let bundle;
+    try {
+      bundle = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    } catch (err) {
+      context.output.error('Invalid JSON file: ' + err.message);
+      return;
+    }
+
+    // Validate the bundle has expected fields
+    if (!bundle.config) {
+      context.output.error('Invalid export file: missing config data.');
+      return;
+    }
+
+    const imported = writeImportedFiles(bundle);
+    const profileName = bundle.profile || 'default';
+
+    context.output.info(`Config imported from ${filePath} (${imported} file(s)).`);
+    writeSyncTimestamp(profileName);
+    printNextSteps(context);
+    return;
+  }
+
+  // --- Remote import mode ---
+  // Read current config to get backup settings
+  const config = readConfigFile('config.json');
+  if (!config || !config.backup) {
+    context.output.info('No backup storage configured.');
+    context.output.info('Run "dev config init" to set up backup storage, or use --file to import from a local file.');
+    return;
+  }
+
+  const backend = config.backup.backend;
+  const location = config.backup.location;
+
+  if (backend === 'repo') {
+    // Check gh authentication
+    const isAuth = await github.isAuthenticated();
+    if (!isAuth) {
+      context.output.info('Not authenticated with GitHub. Run: gh auth login');
+      return;
+    }
+
+    const cacheDir = path.join(DEVUTILS_DIR, 'cache');
+    const repoDir = path.join(cacheDir, 'config-backup');
+    fs.mkdirSync(cacheDir, { recursive: true });
+
+    // Clone or pull the repo
+    if (fs.existsSync(path.join(repoDir, '.git'))) {
+      const pullResult = await github.pullRepo(repoDir);
+      if (!pullResult.success) {
+        context.output.error('Failed to pull latest config: ' + pullResult.error);
+        return;
+      }
+    } else {
+      if (!location) {
+        context.output.info('No backup repository configured.');
+        context.output.info('Run "dev config init --force" to set up a backup repository.');
+        return;
+      }
+
+      const cloneResult = await github.cloneRepo(location, repoDir);
+      if (!cloneResult.success) {
+        context.output.error('Failed to clone backup repo: ' + cloneResult.error);
+        return;
+      }
+    }
+
+    // List available profiles
+    const profilesDir = path.join(repoDir, 'profiles');
+    if (!fs.existsSync(profilesDir)) {
+      context.output.info('No profiles found in backup repository.');
+      return;
+    }
+
+    const profiles = fs.readdirSync(profilesDir, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name);
+
+    if (profiles.length === 0) {
+      context.output.info('No profiles found in backup repository.');
+      return;
+    }
+
+    // Select profile
+    let profileName = args.flags.profile;
+    if (!profileName) {
+      if (profiles.length === 1) {
+        profileName = profiles[0];
+      } else {
+        // Let the user pick
+        profileName = await context.prompt.choose(
+          'Which profile do you want to import?',
+          profiles
+        );
+      }
+    }
+
+    const profileDir = path.join(profilesDir, profileName);
+    if (!fs.existsSync(profileDir)) {
+      context.output.info(`Profile "${profileName}" not found in backup.`);
+      context.output.info(`Available profiles: ${profiles.join(', ')}`);
+      return;
+    }
+
+    // Copy config files from the profile directory into ~/.devutils/
+    const filesToCopy = ['config.json', 'aliases.json', 'ai.json', 'plugins.json'];
+    let imported = 0;
+
+    for (const filename of filesToCopy) {
+      const sourcePath = path.join(profileDir, filename);
+      if (fs.existsSync(sourcePath)) {
+        fs.copyFileSync(sourcePath, path.join(DEVUTILS_DIR, filename));
+        imported++;
+      }
+    }
+
+    context.output.info(`Imported ${imported} config file(s) from profile "${profileName}".`);
+    writeSyncTimestamp(profileName);
+    printNextSteps(context);
+
+  } else if (backend === 'gist') {
+    if (!location) {
+      context.output.info('No backup gist configured.');
+      context.output.info('Run "dev config init --force" to set up a backup gist.');
+      return;
+    }
+
+    // Check gh authentication
+    const isAuth = await github.isAuthenticated();
+    if (!isAuth) {
+      context.output.info('Not authenticated with GitHub. Run: gh auth login');
+      return;
+    }
+
+    const gistResult = await github.getGist(location);
+    if (!gistResult.success) {
+      context.output.error('Failed to read gist: ' + gistResult.error);
+      return;
+    }
+
+    // List available profiles (each is a .json file in the gist)
+    const profileFiles = Object.keys(gistResult.files).filter(f => f.endsWith('.json'));
+    const profiles = profileFiles.map(f => f.replace('.json', ''));
+
+    if (profiles.length === 0) {
+      context.output.info('No profiles found in backup gist.');
+      return;
+    }
+
+    let profileName = args.flags.profile;
+    if (!profileName) {
+      if (profiles.length === 1) {
+        profileName = profiles[0];
+      } else {
+        profileName = await context.prompt.choose(
+          'Which profile do you want to import?',
+          profiles
+        );
+      }
+    }
+
+    const filename = profileName + '.json';
+    const content = gistResult.files[filename];
+    if (!content) {
+      context.output.info(`Profile "${profileName}" not found in gist.`);
+      context.output.info(`Available profiles: ${profiles.join(', ')}`);
+      return;
+    }
+
+    let bundle;
+    try {
+      bundle = JSON.parse(content);
+    } catch {
+      context.output.error('Failed to parse profile data from gist.');
+      return;
+    }
+
+    const imported = writeImportedFiles(bundle);
+    context.output.info(`Imported ${imported} config file(s) from profile "${profileName}".`);
+    writeSyncTimestamp(profileName);
+    printNextSteps(context);
+
+  } else {
+    context.output.info(`Unknown backup backend: ${backend}`);
+    context.output.info('Run "dev config init --force" to reconfigure backup storage.');
+  }
+}
+
+module.exports = { meta, run };

package/src/commands/config/index.js

@@ -0,0 +1,17 @@
+/**
+ * Config service registration.
+ * User configuration and onboarding.
+ */
+module.exports = {
+  name: 'config',
+  description: 'User configuration and onboarding',
+  commands: {
+    init:   () => require('./init'),
+    show:   () => require('./show'),
+    get:    () => require('./get'),
+    set:    () => require('./set'),
+    reset:  () => require('./reset'),
+    export: () => require('./export'),
+    import: () => require('./import'),
+  }
+};

package/src/commands/config/init.js

@@ -0,0 +1,143 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const DEVUTILS_DIR = path.join(os.homedir(), '.devutils');
+const CONFIG_FILE = path.join(DEVUTILS_DIR, 'config.json');
+
+const meta = {
+  description: 'First-run onboarding wizard. Sets up ~/.devutils/ and creates config.json.',
+  arguments: [],
+  flags: [
+    { name: 'force', type: 'boolean', description: 'Re-run setup even if already configured' },
+    { name: 'profile', type: 'string', description: 'Set the profile name (skip the prompt)' },
+  ],
+};
+
+/**
+ * Detects the user's shell config file path for PATH modification.
+ * @returns {{ shell: string, file: string }|null}
+ */
+function getShellConfig() {
+  const shell = process.env.SHELL || '';
+  const home = os.homedir();
+
+  if (shell.includes('zsh')) {
+    return { shell: 'zsh', file: path.join(home, '.zshrc') };
+  }
+  if (shell.includes('bash')) {
+    return { shell: 'bash', file: path.join(home, '.bashrc') };
+  }
+  if (shell.includes('fish')) {
+    return { shell: 'fish', file: path.join(home, '.config', 'fish', 'config.fish') };
+  }
+  return null;
+}
+
+/**
+ * Adds the devutils bin directory to the user's PATH via shell config.
+ * Idempotent: checks if the line is already present before adding.
+ * @param {string} shellFile - The shell config file path.
+ */
+function addToPathFile(shellFile) {
+  const exportLine = 'export PATH="$HOME/.devutils/bin:$PATH"';
+
+  // Create the file if it doesn't exist
+  if (!fs.existsSync(shellFile)) {
+    fs.mkdirSync(path.dirname(shellFile), { recursive: true });
+    fs.writeFileSync(shellFile, '', 'utf8');
+  }
+
+  const content = fs.readFileSync(shellFile, 'utf8');
+
+  // Check if the line is already there
+  if (content.includes('.devutils/bin')) {
+    return false; // Already present
+  }
+
+  fs.appendFileSync(shellFile, '\n# DevUtils CLI\n' + exportLine + '\n');
+  return true; // Added
+}
+
+async function run(args, context) {
+  // Check if already configured
+  if (fs.existsSync(CONFIG_FILE) && !args.flags.force) {
+    context.output.info('DevUtils is already configured. Use --force to re-run setup.');
+    return;
+  }
+
+  // Create the directory structure
+  fs.mkdirSync(path.join(DEVUTILS_DIR, 'machines'), { recursive: true });
+  fs.mkdirSync(path.join(DEVUTILS_DIR, 'bin'), { recursive: true });
+  fs.mkdirSync(path.join(DEVUTILS_DIR, 'auth'), { recursive: true });
+  fs.mkdirSync(path.join(DEVUTILS_DIR, 'plugins'), { recursive: true });
+  fs.mkdirSync(path.join(DEVUTILS_DIR, 'utils'), { recursive: true });
+  fs.mkdirSync(path.join(DEVUTILS_DIR, 'cache'), { recursive: true });
+
+  // Prompt for user info
+  const name = await context.prompt.ask('Your full name', '');
+  const email = await context.prompt.ask('Your email address', '');
+  const url = await context.prompt.ask('Your URL (optional)', '');
+
+  // Prompt for backup backend
+  const backupBackend = await context.prompt.choose(
+    'Where should DevUtils store configuration backups?',
+    ['repo', 'gist'],
+    0
+  );
+
+  // Prompt for profile name
+  const profile = args.flags.profile || await context.prompt.ask('Profile name for this machine', 'default');
+
+  // Build and write config
+  const config = {
+    user: {
+      name: name,
+      email: email,
+      url: url,
+    },
+    defaults: {
+      license: 'MIT',
+      packageManager: 'npm',
+    },
+    backup: {
+      backend: backupBackend,
+      location: null,
+    },
+    profile: profile,
+  };
+
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + '\n');
+
+  // Offer to add ~/.devutils/bin to PATH
+  const shellConfig = getShellConfig();
+  if (shellConfig) {
+    const addToPath = await context.prompt.confirm(
+      'Add ~/.devutils/bin to your PATH? (required for aliases to work)',
+      true
+    );
+    if (addToPath) {
+      const added = addToPathFile(shellConfig.file);
+      if (added) {
+        context.output.info(`Added to ${shellConfig.file}. Restart your terminal or run: source ${shellConfig.file}`);
+      } else {
+        context.output.info('PATH entry already exists. No changes made.');
+      }
+    }
+  }
+
+  // Print summary
+  context.output.info('');
+  context.output.info('DevUtils configured successfully!');
+  context.output.info('');
+  context.output.info(`  Name:     ${name || '(not set)'}`);
+  context.output.info(`  Email:    ${email || '(not set)'}`);
+  context.output.info(`  Profile:  ${profile}`);
+  context.output.info(`  Backup:   ${backupBackend}`);
+  context.output.info(`  Config:   ${CONFIG_FILE}`);
+  context.output.info('');
+}
+
+module.exports = { meta, run };

package/src/commands/config/reset.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_FILE = path.join(os.homedir(), '.devutils', 'config.json');
+
+const meta = {
+  description: 'Reset configuration to defaults. Clears user info and restores default settings.',
+  arguments: [],
+  flags: [
+    { name: 'confirm', type: 'boolean', description: 'Skip the confirmation prompt' },
+  ],
+};
+
+async function run(args, context) {
+  if (!fs.existsSync(CONFIG_FILE)) {
+    context.errors.throwError(404, 'Config not found. Nothing to reset.', 'config');
+    return;
+  }
+
+  // Ask for confirmation unless --confirm is passed
+  if (!args.flags.confirm) {
+    const proceed = await context.prompt.confirm(
+      'This will reset all configuration to defaults. Your user info will be cleared. Continue?',
+      false
+    );
+    if (!proceed) {
+      context.output.info('Reset cancelled.');
+      return;
+    }
+  }
+
+  // Write default config
+  const defaults = {
+    user: {
+      name: '',
+      email: '',
+      url: '',
+    },
+    defaults: {
+      license: 'MIT',
+      packageManager: 'npm',
+    },
+    backup: {
+      backend: null,
+      location: null,
+    },
+    profile: 'default',
+  };
+
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(defaults, null, 2) + '\n');
+  context.output.info('Configuration reset to defaults.');
+}
+
+module.exports = { meta, run };

package/src/commands/config/set.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_FILE = path.join(os.homedir(), '.devutils', 'config.json');
+
+const meta = {
+  description: 'Write a config value by dot-notation key.',
+  arguments: [
+    { name: 'key', required: true, description: 'Dot-notation path to the config value (e.g., user.email)' },
+    { name: 'value', required: false, description: 'The value to set. Omit if using --json.' },
+  ],
+  flags: [
+    { name: 'json', type: 'string', description: 'Set a structured value using a JSON string' },
+  ],
+};
+
+async function run(args, context) {
+  const key = args.positional[0];
+  const rawValue = args.positional[1];
+  const jsonValue = args.flags.json;
+
+  if (!key) {
+    context.errors.throwError(400, 'Missing required argument: <key>. Example: dev config set user.email fred@example.com', 'config');
+    return;
+  }
+
+  if (!rawValue && rawValue !== '' && !jsonValue) {
+    context.errors.throwError(400, 'Missing value. Provide a value or use --json for structured data.', 'config');
+    return;
+  }
+
+  if (rawValue && jsonValue) {
+    context.errors.throwError(400, 'Provide either a positional value or --json, not both.', 'config');
+    return;
+  }
+
+  // Parse the value
+  let value;
+  if (jsonValue) {
+    try {
+      value = JSON.parse(jsonValue);
+    } catch (err) {
+      context.errors.throwError(400, `Invalid JSON: ${err.message}`, 'config');
+      return;
+    }
+  } else {
+    // Coerce simple types
+    if (rawValue === 'true') {
+      value = true;
+    } else if (rawValue === 'false') {
+      value = false;
+    } else if (rawValue === 'null') {
+      value = null;
+    } else if (!isNaN(rawValue) && rawValue.trim() !== '') {
+      value = Number(rawValue);
+    } else {
+      value = rawValue;
+    }
+  }
+
+  // Read existing config
+  if (!fs.existsSync(CONFIG_FILE)) {
+    context.errors.throwError(404, 'Config not found. Run "dev config init" first.', 'config');
+    return;
+  }
+
+  const raw = fs.readFileSync(CONFIG_FILE, 'utf8');
+  const config = JSON.parse(raw);
+
+  // Set value by dot-notation key
+  const parts = key.split('.');
+  let target = config;
+
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!(part in target) || typeof target[part] !== 'object' || target[part] === null) {
+      target[part] = {};
+    }
+    target = target[part];
+  }
+
+  const lastPart = parts[parts.length - 1];
+  target[lastPart] = value;
+
+  // Write config back
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + '\n');
+  context.output.out({ key: key, value: value });
+}
+
+module.exports = { meta, run };

package/src/commands/config/show.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_FILE = path.join(os.homedir(), '.devutils', 'config.json');
+
+const meta = {
+  description: 'Display the current configuration.',
+  arguments: [],
+  flags: [
+    { name: 'profile', type: 'string', description: 'Show a specific profile instead of the active one' },
+  ],
+};
+
+async function run(args, context) {
+  if (!fs.existsSync(CONFIG_FILE)) {
+    context.errors.throwError(404, 'Config not found. Run "dev config init" first.', 'config');
+    return;
+  }
+
+  const raw = fs.readFileSync(CONFIG_FILE, 'utf8');
+  const config = JSON.parse(raw);
+
+  // Handle --profile flag
+  if (args.flags.profile && args.flags.profile !== config.profile) {
+    context.errors.throwError(404, `Profile "${args.flags.profile}" not found. Current profile is "${config.profile}".`, 'config');
+    return;
+  }
+
+  context.output.out(config);
+}
+
+module.exports = { meta, run };