@fredlackey/devutils 0.0.19 → 0.1.0

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 };

package/src/commands/ignore/add.js

@@ -0,0 +1,165 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { MARKER_START, MARKER_END } = require('./markers');
+
+const meta = {
+  description: 'Add gitignore patterns for a technology',
+  arguments: [
+    { name: 'technology', description: 'Technology name (e.g., node, macos, docker)', required: true }
+  ],
+  flags: [
+    { name: 'path', description: 'Target directory (defaults to current directory)', type: 'string', default: '.' }
+  ]
+};
+
+/**
+ * Resolves the absolute path to a pattern file for a given technology.
+ * Uses __dirname so the path is relative to the installed package, not the
+ * user's working directory.
+ *
+ * @param {string} technology - Technology name (e.g., 'node').
+ * @returns {string} Absolute path to the pattern file.
+ */
+function getPatternFilePath(technology) {
+  return path.resolve(__dirname, '../../patterns/gitignore', `${technology}.txt`);
+}
+
+/**
+ * Adds gitignore patterns for a technology to the .gitignore in the target
+ * directory. If the section already exists, it is replaced in place (idempotent).
+ * If the .gitignore does not exist, it is created.
+ *
+ * @param {object} args - Parsed command arguments ({ positional, flags }).
+ * @param {object} context - The DevUtils context object.
+ */
+async function run(args, context) {
+  const technology = args.positional[0];
+
+  // Validate: technology name is required
+  if (!technology) {
+    context.errors.throwError(400, 'Missing required argument: <technology>. Example: dev ignore add node', 'ignore');
+    return;
+  }
+
+  // Step A: Validate the technology name and read the pattern file
+  const patternFilePath = getPatternFilePath(technology);
+  if (!fs.existsSync(patternFilePath)) {
+    context.errors.throwError(404, `Unknown technology "${technology}". Run "dev ignore list" to see available options.`, 'ignore');
+    return;
+  }
+
+  const patternContent = fs.readFileSync(patternFilePath, 'utf8').trimEnd();
+
+  // Step B: Resolve the target .gitignore path
+  const flagPath = args.flags.path || '.';
+  const gitignorePath = path.resolve(flagPath, '.gitignore');
+
+  // Step C: Read existing .gitignore or start empty
+  let existingContent = '';
+  let fileExists = false;
+  if (fs.existsSync(gitignorePath)) {
+    existingContent = fs.readFileSync(gitignorePath, 'utf8');
+    fileExists = true;
+  }
+
+  // Step D: Build the new section
+  const section = [
+    MARKER_START(technology),
+    patternContent,
+    MARKER_END(technology)
+  ].join('\n');
+
+  // Step E: Check if the section already exists
+  const lines = existingContent.split(/\r?\n/);
+  const startMarker = MARKER_START(technology);
+  const endMarker = MARKER_END(technology);
+  const startIndex = lines.findIndex(line => line.trim() === startMarker);
+  const endIndex = lines.findIndex(line => line.trim() === endMarker);
+
+  let updatedContent;
+  let action;
+
+  if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+    // Both markers found: replace the existing section in place
+    const before = lines.slice(0, startIndex);
+    const after = lines.slice(endIndex + 1);
+    const sectionLines = section.split('\n');
+    const newLines = [...before, ...sectionLines, ...after];
+    updatedContent = newLines.join('\n');
+    action = 'updated';
+  } else if (startIndex !== -1 || endIndex !== -1) {
+    // Only one marker found: corrupted state. Warn and append.
+    if (!context.flags.quiet) {
+      context.output.info(`Warning: Found partial markers for "${technology}" in .gitignore. Appending new section at end.`);
+    }
+    updatedContent = existingContent;
+    // Ensure a blank line before the new section
+    if (updatedContent.length > 0 && !updatedContent.endsWith('\n\n') && !updatedContent.endsWith('\n')) {
+      updatedContent += '\n';
+    }
+    if (updatedContent.length > 0 && !updatedContent.endsWith('\n\n')) {
+      updatedContent += '\n';
+    }
+    updatedContent += section;
+    action = 'added';
+  } else {
+    // No markers found: fresh add, append to end
+    updatedContent = existingContent;
+    // Step F: Ensure a blank line before the new section
+    if (updatedContent.length > 0) {
+      if (!updatedContent.endsWith('\n')) {
+        updatedContent += '\n';
+      }
+      if (!updatedContent.endsWith('\n\n')) {
+        updatedContent += '\n';
+      }
+    }
+    updatedContent += section;
+    action = 'added';
+  }
+
+  // Make sure the file ends with a trailing newline
+  if (!updatedContent.endsWith('\n')) {
+    updatedContent += '\n';
+  }
+
+  // Count pattern lines (lines between markers, not including markers)
+  const sectionLines = section.split('\n');
+  const patternLineCount = sectionLines.length - 2; // minus start and end markers
+
+  // Step G: Handle --dry-run
+  if (context.flags.dryRun) {
+    if (context.flags.format === 'json') {
+      context.output.out({
+        technology,
+        action,
+        path: gitignorePath,
+        lines: patternLineCount,
+        dryRun: true
+      });
+    } else {
+      context.output.info(`[dry-run] Would have ${action} ${technology} patterns in ${gitignorePath} (${patternLineCount} lines)`);
+    }
+    return;
+  }
+
+  // Step G: Write the result
+  fs.writeFileSync(gitignorePath, updatedContent);
+
+  // Step H: Output the result
+  if (context.flags.format === 'json') {
+    context.output.out({
+      technology,
+      action,
+      path: gitignorePath,
+      lines: patternLineCount
+    });
+  } else {
+    const verb = action === 'updated' ? 'Updated' : 'Added';
+    context.output.info(`${verb} ${technology} patterns ${action === 'updated' ? 'in' : 'to'} .gitignore`);
+  }
+}
+
+module.exports = { meta, run };

package/src/commands/ignore/index.js

@@ -0,0 +1,14 @@
+/**
+ * Ignore service registration.
+ * .gitignore pattern management.
+ */
+module.exports = {
+  name: 'ignore',
+  description: '.gitignore pattern management',
+  commands: {
+    add:    () => require('./add'),
+    remove: () => require('./remove'),
+    list:   () => require('./list'),
+    show:   () => require('./show'),
+  }
+};

package/src/commands/ignore/list.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+const meta = {
+  description: 'List available gitignore pattern technologies',
+  arguments: [],
+  flags: []
+};
+
+/**
+ * Returns the absolute path to the gitignore patterns directory.
+ * Uses __dirname so the path is relative to the installed package.
+ *
+ * @returns {string} Absolute path to the patterns directory.
+ */
+function getPatternsDir() {
+  return path.resolve(__dirname, '../../patterns/gitignore');
+}
+
+/**
+ * Lists all available gitignore pattern technologies by scanning the
+ * patterns directory. Each .txt file represents one technology. The
+ * technology name is the filename without the .txt extension.
+ *
+ * @param {object} args - Parsed command arguments ({ positional, flags }).
+ * @param {object} context - The DevUtils context object.
+ */
+async function run(args, context) {
+  const patternsDir = getPatternsDir();
+
+  // Step A: Read the patterns directory
+  if (!fs.existsSync(patternsDir)) {
+    context.errors.throwError(500, 'Patterns directory not found. The DevUtils installation may be corrupted.', 'ignore');
+    return;
+  }
+
+  const files = fs.readdirSync(patternsDir)
+    .filter(f => f.endsWith('.txt'))
+    .sort();
+
+  if (files.length === 0) {
+    context.errors.throwError(500, 'No pattern files found. The DevUtils installation may be corrupted.', 'ignore');
+    return;
+  }
+
+  // Step B: Read the first comment line from each file as a description
+  const technologies = files.map(file => {
+    const name = file.replace(/\.txt$/, '');
+    let description = name;
+
+    try {
+      const content = fs.readFileSync(path.join(patternsDir, file), 'utf8');
+      const firstLine = content.split(/\r?\n/)[0];
+      if (firstLine && firstLine.startsWith('# ')) {
+        description = firstLine.slice(2).trim();
+      }
+    } catch {
+      // If we can't read the file, fall back to the name
+    }
+
+    return { name, description };
+  });
+
+  // Step C: Build the result
+  const result = {
+    technologies,
+    count: technologies.length
+  };
+
+  // Step D: Format the output
+  if (context.flags.format === 'json') {
+    context.output.out(result);
+  } else {
+    // Calculate padding for aligned columns
+    const maxNameLength = Math.max(...technologies.map(t => t.name.length));
+
+    context.output.info('Available technologies:');
+    for (const tech of technologies) {
+      const paddedName = tech.name.padEnd(maxNameLength + 2);
+      context.output.info(`  ${paddedName}${tech.description}`);
+    }
+    context.output.info('');
+    context.output.info('Use "dev ignore add <technology>" to add patterns to .gitignore.');
+  }
+}
+
+module.exports = { meta, run };

package/src/commands/ignore/markers.js

@@ -0,0 +1,43 @@
+'use strict';
+
+/**
+ * Shared marker constants for DevUtils-managed .gitignore sections.
+ *
+ * These markers wrap each technology's patterns so that the ignore commands
+ * can identify, replace, and remove sections without disturbing manually
+ * added patterns. The format is:
+ *
+ *   # >>> devutils:<name>
+ *   ... patterns ...
+ *   # <<< devutils:<name>
+ *
+ * @module commands/ignore/markers
+ */
+
+/**
+ * Returns the start marker for a given technology name.
+ * @param {string} name - Technology name (e.g., 'node', 'macos').
+ * @returns {string} The start marker line.
+ */
+const MARKER_START = (name) => `# >>> devutils:${name}`;
+
+/**
+ * Returns the end marker for a given technology name.
+ * @param {string} name - Technology name (e.g., 'node', 'macos').
+ * @returns {string} The end marker line.
+ */
+const MARKER_END = (name) => `# <<< devutils:${name}`;
+
+/**
+ * The prefix used to identify start markers when parsing .gitignore files.
+ * @type {string}
+ */
+const MARKER_START_PREFIX = '# >>> devutils:';
+
+/**
+ * The prefix used to identify end markers when parsing .gitignore files.
+ * @type {string}
+ */
+const MARKER_END_PREFIX = '# <<< devutils:';
+
+module.exports = { MARKER_START, MARKER_END, MARKER_START_PREFIX, MARKER_END_PREFIX };