@fredlackey/devutils 0.0.18 → 0.1.0

package/src/commands/identity/add.js

@@ -0,0 +1,133 @@
+'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: 'Create a new identity profile.',
+  arguments: [
+    { name: 'name', description: 'Short name for this identity (e.g., personal, work)', required: true },
+  ],
+  flags: [
+    { name: 'email', description: 'Git author email (required)' },
+    { name: 'ssh-key', description: 'Path to SSH private key file' },
+    { name: 'gpg-key', description: 'GPG key ID for commit signing' },
+    { name: 'generate-key', description: 'Generate a new SSH key pair for this identity' },
+  ],
+};
+
+async function run(args, context) {
+  const identityName = args.positional[0];
+  if (!identityName) {
+    context.errors.throwError(400, 'Missing identity name. Usage: dev identity add <name> --email <email>', 'identity');
+    return;
+  }
+
+  // Validate name format
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(identityName)) {
+    context.errors.throwError(400, 'Identity name must be lowercase letters, numbers, and hyphens only.', 'identity');
+    return;
+  }
+
+  const email = args.flags.email;
+  if (!email) {
+    context.errors.throwError(400, 'Email is required. Use --email your@email.com.', 'identity');
+    return;
+  }
+
+  // Load config
+  if (!fs.existsSync(CONFIG_FILE)) {
+    context.errors.throwError(404, 'Config not found. Run "dev config init" first.', 'identity');
+    return;
+  }
+  const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  const identities = config.identities || [];
+
+  // Check for duplicates (case-insensitive)
+  if (identities.some(id => id.name.toLowerCase() === identityName.toLowerCase())) {
+    context.errors.throwError(400, `Identity '${identityName}' already exists. Use a different name or remove it first.`, 'identity');
+    return;
+  }
+
+  // Handle SSH key
+  let sshKeyPath = null;
+  const sshKeyFlag = args.flags['ssh-key'];
+  const generateKey = args.flags['generate-key'];
+
+  if (sshKeyFlag && generateKey) {
+    context.errors.throwError(400, 'Provide either --ssh-key or --generate-key, not both.', 'identity');
+    return;
+  }
+
+  if (sshKeyFlag) {
+    const resolved = path.resolve(sshKeyFlag);
+    if (!fs.existsSync(resolved)) {
+      context.errors.throwError(404, `SSH key file not found: ${resolved}`, 'identity');
+      return;
+    }
+    sshKeyPath = resolved;
+  } else if (generateKey) {
+    sshKeyPath = await generateSshKey(identityName, email, context);
+    if (!sshKeyPath) return; // Error already reported
+  }
+
+  // Handle GPG key
+  const gpgKey = args.flags['gpg-key'] || null;
+
+  // Build identity
+  const identity = {
+    name: identityName,
+    email: email,
+    sshKey: sshKeyPath,
+    gpgKey: gpgKey,
+    folders: [],
+  };
+
+  // Save
+  identities.push(identity);
+  config.identities = identities;
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + '\n');
+
+  context.output.info(`Identity '${identityName}' created.`);
+  context.output.out(identity);
+}
+
+/**
+ * Generates an ED25519 SSH key pair for the given identity.
+ * @param {string} name - The identity name (used in the key filename).
+ * @param {string} email - The email (used as the key comment).
+ * @param {object} context - The command context.
+ * @returns {Promise<string|null>} The key path, or null on failure.
+ */
+async function generateSshKey(name, email, context) {
+  const sshDir = path.join(os.homedir(), '.ssh');
+  if (!fs.existsSync(sshDir)) {
+    fs.mkdirSync(sshDir, { mode: 0o700 });
+  }
+
+  const keyPath = path.join(sshDir, `id_ed25519_${name}`);
+  if (fs.existsSync(keyPath)) {
+    context.errors.throwError(400, `SSH key already exists at ${keyPath}. Use --ssh-key ${keyPath} to reference it.`, 'identity');
+    return null;
+  }
+
+  const result = await context.shell.exec(
+    `ssh-keygen -t ed25519 -C "${email}" -f "${keyPath}" -N ""`
+  );
+
+  if (result.exitCode !== 0) {
+    context.errors.throwError(500, `Failed to generate SSH key: ${result.stderr}`, 'identity');
+    return null;
+  }
+
+  context.output.info(`SSH key generated: ${keyPath}`);
+  context.output.info(`Public key: ${keyPath}.pub`);
+  context.output.info('Add the public key to your GitHub account at https://github.com/settings/keys');
+
+  return keyPath;
+}
+
+module.exports = { meta, run };

package/src/commands/identity/index.js

@@ -0,0 +1,17 @@
+/**
+ * Identity service registration.
+ * Git identities, SSH keys, GPG signing.
+ */
+module.exports = {
+  name: 'identity',
+  description: 'Git identities, SSH keys, GPG signing',
+  commands: {
+    add:    () => require('./add'),
+    remove: () => require('./remove'),
+    list:   () => require('./list'),
+    show:   () => require('./show'),
+    link:   () => require('./link'),
+    unlink: () => require('./unlink'),
+    sync:   () => require('./sync'),
+  }
+};

package/src/commands/identity/link.js

@@ -0,0 +1,76 @@
+'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: 'Link an identity to a folder path.',
+  arguments: [
+    { name: 'name', description: 'Identity name', required: true },
+    { name: 'folder', description: 'Folder path to link (absolute or relative)', required: true },
+  ],
+  flags: [
+    { name: 'remote', description: 'Git remote hostname (default: github.com)' },
+  ],
+};
+
+async function run(args, context) {
+  const name = args.positional[0];
+  const folder = args.positional[1];
+
+  if (!name || !folder) {
+    context.errors.throwError(400, 'Usage: dev identity link <name> <folder> [--remote <host>]', 'identity');
+    return;
+  }
+
+  const absolutePath = path.resolve(folder);
+  if (!fs.existsSync(absolutePath)) {
+    context.errors.throwError(404, `Folder not found: ${absolutePath}`, 'identity');
+    return;
+  }
+
+  if (!fs.existsSync(CONFIG_FILE)) {
+    context.errors.throwError(404, 'Config not found. Run "dev config init" first.', 'identity');
+    return;
+  }
+  const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  const identities = config.identities || [];
+
+  // Find the target identity
+  const identity = identities.find(id => id.name.toLowerCase() === name.toLowerCase());
+  if (!identity) {
+    context.errors.throwError(404, `Identity '${name}' not found.`, 'identity');
+    return;
+  }
+
+  const remote = args.flags.remote || 'github.com';
+
+  // Check if folder is linked to a different identity
+  for (const id of identities) {
+    const existing = (id.folders || []).find(f => f.path === absolutePath);
+    if (existing && id.name.toLowerCase() !== name.toLowerCase()) {
+      context.output.info(`Warning: Folder '${absolutePath}' is currently linked to identity '${id.name}'. Re-linking to '${identity.name}'.`);
+    }
+  }
+
+  // Remove folder from all identities (avoid duplicates)
+  for (const id of identities) {
+    id.folders = (id.folders || []).filter(f => f.path !== absolutePath);
+  }
+
+  // Add the link
+  identity.folders = identity.folders || [];
+  identity.folders.push({ path: absolutePath, remote });
+
+  // Save
+  config.identities = identities;
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + '\n');
+
+  context.output.info(`Linked '${absolutePath}' to identity '${identity.name}' (remote: ${remote}).`);
+  context.output.info("Run 'dev identity sync' to apply changes to SSH and git config.");
+}
+
+module.exports = { meta, run };

package/src/commands/identity/list.js

@@ -0,0 +1,48 @@
+'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: 'List all configured identities.',
+  arguments: [],
+  flags: [],
+};
+
+async function run(args, context) {
+  if (!fs.existsSync(CONFIG_FILE)) {
+    context.errors.throwError(404, 'Config not found. Run "dev config init" first.', 'identity');
+    return;
+  }
+  const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  const identities = config.identities || [];
+
+  if (identities.length === 0) {
+    context.output.info('No identities configured.');
+    context.output.info('');
+    context.output.info('Create one with:');
+    context.output.info('  dev identity add <name> --email <email>');
+    context.output.info('');
+    context.output.info('Example:');
+    context.output.info('  dev identity add personal --email fred@example.com');
+    return;
+  }
+
+  // Build table rows
+  const rows = identities.map(id => ({
+    Name: id.name,
+    Email: id.email,
+    'SSH Key': id.sshKey ? 'yes' : 'no',
+    'GPG Key': id.gpgKey ? 'yes' : 'no',
+    'Linked Folders': (id.folders || []).length,
+  }));
+
+  context.output.out(rows);
+  const count = identities.length;
+  context.output.info(`\n${count} ${count === 1 ? 'identity' : 'identities'} configured.`);
+}
+
+module.exports = { meta, run };

package/src/commands/identity/remove.js

@@ -0,0 +1,72 @@
+'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: 'Remove an identity profile.',
+  arguments: [
+    { name: 'name', description: 'Name of the identity to remove', required: true },
+  ],
+  flags: [
+    { name: 'confirm', description: 'Skip the confirmation prompt' },
+    { name: 'force', description: 'Remove even if the identity has linked folders' },
+  ],
+};
+
+async function run(args, context) {
+  const name = args.positional[0];
+  if (!name) {
+    context.errors.throwError(400, 'Missing identity name. Usage: dev identity remove <name>', 'identity');
+    return;
+  }
+
+  if (!fs.existsSync(CONFIG_FILE)) {
+    context.errors.throwError(404, 'Config not found. Run "dev config init" first.', 'identity');
+    return;
+  }
+  const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  const identities = config.identities || [];
+
+  // Find the identity
+  const identity = identities.find(id => id.name.toLowerCase() === name.toLowerCase());
+  if (!identity) {
+    context.errors.throwError(404, `Identity '${name}' not found.`, 'identity');
+    return;
+  }
+
+  // Check for linked folders
+  const folders = identity.folders || [];
+  if (folders.length > 0 && !args.flags.force) {
+    const folderList = folders.map(f => `  ${f.path || f}`).join('\n');
+    context.errors.throwError(
+      400,
+      `Cannot remove identity '${identity.name}' because it has ${folders.length} linked folder(s):\n${folderList}\nUse --force to remove anyway, or unlink the folders first.`,
+      'identity'
+    );
+    return;
+  }
+
+  // Confirm
+  if (!args.flags.confirm) {
+    const proceed = await context.prompt.confirm(`Remove identity '${identity.name}'? This cannot be undone.`, false);
+    if (!proceed) {
+      context.output.info('Cancelled.');
+      return;
+    }
+  }
+
+  // Remove from array
+  config.identities = identities.filter(id => id.name.toLowerCase() !== name.toLowerCase());
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + '\n');
+
+  context.output.info(`Identity '${identity.name}' removed.`);
+  if (identity.sshKey) {
+    context.output.info(`Note: SSH key at ${identity.sshKey} was not deleted. Remove it manually if no longer needed.`);
+  }
+}
+
+module.exports = { meta, run };

package/src/commands/identity/show.js

@@ -0,0 +1,65 @@
+'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: 'Show details of a specific identity.',
+  arguments: [
+    { name: 'name', description: 'Name of the identity to show', required: true },
+  ],
+  flags: [],
+};
+
+async function run(args, context) {
+  const name = args.positional[0];
+  if (!name) {
+    context.errors.throwError(400, 'Missing identity name. Usage: dev identity show <name>', 'identity');
+    return;
+  }
+
+  if (!fs.existsSync(CONFIG_FILE)) {
+    context.errors.throwError(404, 'Config not found. Run "dev config init" first.', 'identity');
+    return;
+  }
+  const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  const identities = config.identities || [];
+
+  const identity = identities.find(id => id.name.toLowerCase() === name.toLowerCase());
+  if (!identity) {
+    context.errors.throwError(404, `Identity '${name}' not found. Run 'dev identity list' to see available identities.`, 'identity');
+    return;
+  }
+
+  // For JSON callers, output the raw object
+  if (context.flags.format === 'json') {
+    context.output.out(identity);
+    return;
+  }
+
+  // Formatted display for humans
+  const sshStatus = identity.sshKey
+    ? `${identity.sshKey} ${fs.existsSync(identity.sshKey) ? '(exists)' : '(missing!)'}`
+    : '(not configured)';
+  const gpgStatus = identity.gpgKey || '(not configured)';
+  const folders = identity.folders || [];
+
+  context.output.info(`Identity: ${identity.name}`);
+  context.output.info('');
+  context.output.info(`  Email:         ${identity.email}`);
+  context.output.info(`  SSH Key:       ${sshStatus}`);
+  context.output.info(`  GPG Key:       ${gpgStatus}`);
+  context.output.info(`  Linked Folders (${folders.length}):`);
+  if (folders.length === 0) {
+    context.output.info('    (none)');
+  } else {
+    for (const f of folders) {
+      context.output.info(`    ${f.path || f}`);
+    }
+  }
+}
+
+module.exports = { meta, run };

package/src/commands/identity/sync.js

@@ -0,0 +1,172 @@
+'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 SSH_START = '# >>> DevUtils Managed SSH Config - DO NOT EDIT BETWEEN MARKERS >>>';
+const SSH_END = '# <<< DevUtils Managed SSH Config <<<';
+const GIT_START = '# >>> DevUtils Managed Git Config - DO NOT EDIT BETWEEN MARKERS >>>';
+const GIT_END = '# <<< DevUtils Managed Git Config <<<';
+
+const meta = {
+  description: 'Regenerate SSH config and git config from identity definitions.',
+  arguments: [],
+  flags: [
+    { name: 'dry-run', description: 'Show what would be written without making changes' },
+  ],
+};
+
+/**
+ * Builds SSH config blocks for an identity.
+ * @param {object} identity - The identity object.
+ * @returns {string} The SSH config block text.
+ */
+function buildSshConfigBlock(identity) {
+  const remotes = [...new Set((identity.folders || []).map(f => f.remote || 'github.com'))];
+  const blocks = [];
+
+  for (const remote of remotes) {
+    blocks.push([
+      `# DevUtils managed - ${identity.name}`,
+      `Host ${remote}-${identity.name}`,
+      `  HostName ${remote}`,
+      `  User git`,
+      `  IdentityFile ${identity.sshKey}`,
+      `  IdentitiesOnly yes`,
+    ].join('\n'));
+  }
+
+  return blocks.join('\n\n');
+}
+
+/**
+ * Updates a config file by replacing content between markers or appending.
+ * @param {string} filePath - The file to update.
+ * @param {string} startMarker - The start marker.
+ * @param {string} endMarker - The end marker.
+ * @param {string} newContent - The new content between markers.
+ * @param {boolean} dryRun - If true, don't write the file.
+ * @param {object} [writeOpts] - Options for writeFileSync (e.g., mode).
+ * @returns {string} The full file content.
+ */
+function updateManagedSection(filePath, startMarker, endMarker, newContent, dryRun, writeOpts = {}) {
+  let existing = '';
+  if (fs.existsSync(filePath)) {
+    existing = fs.readFileSync(filePath, 'utf8');
+  }
+
+  const startIdx = existing.indexOf(startMarker);
+  const endIdx = existing.indexOf(endMarker);
+
+  let updated;
+  if (startIdx !== -1 && endIdx !== -1) {
+    updated = existing.substring(0, startIdx) +
+      startMarker + '\n' + newContent + '\n' + endMarker +
+      existing.substring(endIdx + endMarker.length);
+  } else {
+    updated = existing.trimEnd() + '\n\n' +
+      startMarker + '\n' + newContent + '\n' + endMarker + '\n';
+  }
+
+  if (!dryRun) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { mode: 0o700, recursive: true });
+    }
+    fs.writeFileSync(filePath, updated, writeOpts);
+  }
+
+  return updated;
+}
+
+async function run(args, context) {
+  const dryRun = args.flags['dry-run'] || context.flags.dryRun;
+
+  if (!fs.existsSync(CONFIG_FILE)) {
+    context.errors.throwError(404, 'Config not found. Run "dev config init" first.', 'identity');
+    return;
+  }
+  const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  const identities = config.identities || [];
+
+  if (identities.length === 0) {
+    context.output.info('No identities configured. Nothing to sync.');
+    return;
+  }
+
+  // Build SSH config
+  const sshBlocks = [];
+  for (const id of identities) {
+    if (!id.sshKey) {
+      context.output.info(`Warning: Skipping SSH config for '${id.name}' (no SSH key configured).`);
+      continue;
+    }
+    if ((id.folders || []).length === 0) {
+      context.output.info(`Warning: Identity '${id.name}' has no linked folders.`);
+    }
+    sshBlocks.push(buildSshConfigBlock(id));
+  }
+
+  const sshConfigPath = path.join(os.homedir(), '.ssh', 'config');
+  const sshContent = sshBlocks.join('\n\n');
+
+  if (dryRun) {
+    context.output.info('=== SSH Config (dry run) ===');
+    context.output.info(sshContent || '(no SSH entries)');
+  } else if (sshContent) {
+    updateManagedSection(sshConfigPath, SSH_START, SSH_END, sshContent, false, { mode: 0o600 });
+    context.output.info(`SSH config updated: ${sshConfigPath}`);
+  }
+
+  // Build git config includes
+  const gitConfigPath = path.join(os.homedir(), '.gitconfig');
+  const includeLines = [];
+
+  for (const id of identities) {
+    const folders = id.folders || [];
+    if (folders.length === 0) continue;
+
+    // Write per-identity gitconfig
+    const idConfigPath = path.join(os.homedir(), `.gitconfig-${id.name}`);
+    const lines = ['[user]', `  email = ${id.email}`];
+    if (id.gpgKey) {
+      lines.push(`  signingkey = ${id.gpgKey}`);
+      lines.push('[commit]');
+      lines.push('  gpgsign = true');
+    }
+    const idContent = lines.join('\n') + '\n';
+
+    if (dryRun) {
+      context.output.info(`\n=== ${idConfigPath} (dry run) ===`);
+      context.output.info(idContent);
+    } else {
+      fs.writeFileSync(idConfigPath, idContent);
+    }
+
+    // Build includeIf entries for each unique folder
+    for (const f of folders) {
+      const folderPath = f.path.endsWith('/') ? f.path : f.path + '/';
+      includeLines.push(`[includeIf "gitdir:${folderPath}"]`);
+      includeLines.push(`  path = ${idConfigPath}`);
+    }
+  }
+
+  const gitIncludeContent = includeLines.join('\n');
+
+  if (dryRun) {
+    context.output.info('\n=== Git Config includes (dry run) ===');
+    context.output.info(gitIncludeContent || '(no git config entries)');
+  } else if (gitIncludeContent) {
+    updateManagedSection(gitConfigPath, GIT_START, GIT_END, gitIncludeContent, false);
+    context.output.info(`Git config updated: ${gitConfigPath}`);
+  }
+
+  if (!dryRun) {
+    context.output.info('Sync complete.');
+  }
+}
+
+module.exports = { meta, run };

package/src/commands/identity/unlink.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: 'Remove a folder link from an identity.',
+  arguments: [
+    { name: 'name', description: 'Identity name', required: true },
+    { name: 'folder', description: 'Folder path to unlink', required: true },
+  ],
+  flags: [],
+};
+
+async function run(args, context) {
+  const name = args.positional[0];
+  const folder = args.positional[1];
+
+  if (!name || !folder) {
+    context.errors.throwError(400, 'Usage: dev identity unlink <name> <folder>', 'identity');
+    return;
+  }
+
+  const absolutePath = path.resolve(folder);
+
+  if (!fs.existsSync(CONFIG_FILE)) {
+    context.errors.throwError(404, 'Config not found. Run "dev config init" first.', 'identity');
+    return;
+  }
+  const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  const identities = config.identities || [];
+
+  const identity = identities.find(id => id.name.toLowerCase() === name.toLowerCase());
+  if (!identity) {
+    context.errors.throwError(404, `Identity '${name}' not found.`, 'identity');
+    return;
+  }
+
+  const folders = identity.folders || [];
+  const found = folders.find(f => f.path === absolutePath);
+  if (!found) {
+    context.output.info(`Folder '${absolutePath}' is not linked to identity '${identity.name}'. Nothing to do.`);
+    return;
+  }
+
+  identity.folders = folders.filter(f => f.path !== absolutePath);
+  config.identities = identities;
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + '\n');
+
+  context.output.info(`Unlinked '${absolutePath}' from identity '${identity.name}'.`);
+  context.output.info("Run 'dev identity sync' to update SSH and git config.");
+}
+
+module.exports = { meta, run };