@fredlackey/devutils 0.0.18 → 0.1.0

package/src/commands/config/export.js

@@ -0,0 +1,224 @@
+'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: 'Push the current config profile to the remote backup (repo or gist), or export to a local file.',
+  arguments: [],
+  flags: [
+    { name: 'file', type: 'string', description: 'Export to a local file instead of remote backup' },
+    { name: 'profile', type: 'string', description: 'Export a specific profile (defaults to the active profile)' }
+  ]
+};
+
+/**
+ * The list of config files that are included in an export.
+ * Auth tokens are NOT included -- they are sensitive and should be
+ * re-created on new machines via "dev auth login".
+ */
+const FILES_TO_EXPORT = ['config.json', 'aliases.json', 'ai.json', 'plugins.json'];
+
+/**
+ * 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 the sync timestamp after a successful export.
+ * This is used by future sync-check features to know when the last
+ * export or import happened.
+ *
+ * @param {string} profileName - The profile that was exported.
+ */
+function writeSyncTimestamp(profileName) {
+  const syncPath = path.join(DEVUTILS_DIR, 'sync.json');
+  const syncData = {
+    lastSync: new Date().toISOString(),
+    direction: 'export',
+    profile: profileName
+  };
+  fs.writeFileSync(syncPath, JSON.stringify(syncData, null, 2) + '\n');
+}
+
+/**
+ * Run the config export command.
+ * Supports two modes:
+ * - File mode (--file): Bundles all config files into a single JSON file on disk.
+ * - Remote mode (default): Pushes config to 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');
+
+  // Read current config to get profile and backup settings
+  const config = readConfigFile('config.json');
+  const profileName = args.flags.profile || (config && config.profile) || 'default';
+
+  // --- File export mode ---
+  if (args.flags.file) {
+    const bundle = {
+      exportedAt: new Date().toISOString(),
+      profile: profileName,
+      config: readConfigFile('config.json'),
+      aliases: readConfigFile('aliases.json'),
+      ai: readConfigFile('ai.json'),
+      plugins: readConfigFile('plugins.json')
+    };
+
+    const outputPath = path.resolve(args.flags.file);
+    fs.writeFileSync(outputPath, JSON.stringify(bundle, null, 2) + '\n');
+    context.output.info(`Config exported to ${outputPath}`);
+
+    writeSyncTimestamp(profileName);
+    return;
+  }
+
+  // --- Remote export mode ---
+  if (!config || !config.backup) {
+    context.output.info('No backup storage configured.');
+    context.output.info('Run "dev config init" to set up backup storage.');
+    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'))) {
+      // Already cloned -- pull latest
+      const pullResult = await github.pullRepo(repoDir);
+      if (!pullResult.success) {
+        context.output.error('Failed to pull latest config: ' + pullResult.error);
+        return;
+      }
+    } else {
+      // First time -- need repo location
+      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;
+      }
+    }
+
+    // Copy config files into the profile directory
+    const profileDir = path.join(repoDir, 'profiles', profileName);
+    fs.mkdirSync(profileDir, { recursive: true });
+
+    for (const filename of FILES_TO_EXPORT) {
+      const sourcePath = path.join(DEVUTILS_DIR, filename);
+      if (fs.existsSync(sourcePath)) {
+        fs.copyFileSync(sourcePath, path.join(profileDir, filename));
+      }
+    }
+
+    // Push
+    const pushResult = await github.pushRepo(
+      repoDir,
+      `Update profile "${profileName}" - ${new Date().toISOString()}`
+    );
+
+    if (!pushResult.success) {
+      context.output.error('Failed to push config: ' + pushResult.error);
+      return;
+    }
+
+    context.output.info(`Config exported to repo (profile: ${profileName}).`);
+    writeSyncTimestamp(profileName);
+
+  } else if (backend === 'gist') {
+    // Check gh authentication
+    const isAuth = await github.isAuthenticated();
+    if (!isAuth) {
+      context.output.info('Not authenticated with GitHub. Run: gh auth login');
+      return;
+    }
+
+    // Bundle config files into a single JSON for the gist
+    const bundle = {
+      config: readConfigFile('config.json'),
+      aliases: readConfigFile('aliases.json'),
+      ai: readConfigFile('ai.json'),
+      plugins: readConfigFile('plugins.json')
+    };
+
+    const filename = `${profileName}.json`;
+    const content = JSON.stringify(bundle, null, 2);
+
+    if (location) {
+      // Update existing gist
+      const result = await github.updateGist(location, { [filename]: content });
+      if (!result.success) {
+        context.output.error('Failed to update gist: ' + result.error);
+        return;
+      }
+      context.output.info(`Config exported to gist (profile: ${profileName}).`);
+    } else {
+      // Create new gist
+      const result = await github.createGist(
+        { [filename]: content },
+        'DevUtils CLI configuration backup',
+        true
+      );
+
+      if (!result.success) {
+        context.output.error('Failed to create gist: ' + result.error);
+        return;
+      }
+
+      // Save the gist ID back to config so future exports update the same gist
+      config.backup.location = result.id;
+      fs.writeFileSync(
+        CONFIG_FILE,
+        JSON.stringify(config, null, 2) + '\n'
+      );
+
+      context.output.info(`Config exported to new gist (profile: ${profileName}).`);
+      context.output.info(`Gist URL: ${result.url}`);
+    }
+
+    writeSyncTimestamp(profileName);
+
+  } 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/get.js

@@ -0,0 +1,52 @@
+'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: 'Read a specific config value by dot-notation key.',
+  arguments: [
+    { name: 'key', required: true, description: 'Dot-notation path to the config value (e.g., user.email, defaults.license)' },
+  ],
+  flags: [],
+};
+
+async function run(args, context) {
+  const key = args.positional[0];
+
+  if (!key) {
+    context.errors.throwError(400, 'Missing required argument: <key>. Example: dev config get user.email', 'config');
+    return;
+  }
+
+  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);
+
+  // Resolve dot-notation key
+  const parts = key.split('.');
+  let value = config;
+
+  for (const part of parts) {
+    if (value === null || value === undefined || typeof value !== 'object') {
+      context.errors.throwError(404, `Key "${key}" not found in config.`, 'config');
+      return;
+    }
+    if (!(part in value)) {
+      context.errors.throwError(404, `Key "${key}" not found in config.`, 'config');
+      return;
+    }
+    value = value[part];
+  }
+
+  context.output.out(value);
+}
+
+module.exports = { meta, run };

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'),
+  }
+};