@fredlackey/devutils 0.0.19 → 0.1.0

package/src/commands/ignore/remove.js

@@ -0,0 +1,164 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { MARKER_START, MARKER_END } = require('./markers');
+
+const meta = {
+  description: 'Remove managed gitignore patterns for a technology',
+  arguments: [
+    { name: 'technology', description: 'Technology name to remove (e.g., node, macos)', required: true }
+  ],
+  flags: [
+    { name: 'path', description: 'Target directory (defaults to current directory)', type: 'string', default: '.' }
+  ]
+};
+
+/**
+ * Removes a DevUtils-managed section from the .gitignore in the target
+ * directory. If the section does not exist, this is a no-op (idempotent).
+ * If removing the section leaves the file empty, the file is deleted.
+ *
+ * @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 remove node', 'ignore');
+    return;
+  }
+
+  // Step A: Resolve the .gitignore path
+  const flagPath = args.flags.path || '.';
+  const gitignorePath = path.resolve(flagPath, '.gitignore');
+
+  // Step B: Read existing .gitignore
+  if (!fs.existsSync(gitignorePath)) {
+    if (context.flags.format === 'json') {
+      context.output.out({
+        technology,
+        action: 'none',
+        message: `No .gitignore found at ${path.resolve(flagPath)}.`
+      });
+    } else {
+      context.output.info(`No .gitignore found at ${path.resolve(flagPath)}.`);
+    }
+    return;
+  }
+
+  const existingContent = fs.readFileSync(gitignorePath, 'utf8');
+
+  // Step C: Find the section markers
+  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);
+
+  if (startIndex === -1 && endIndex === -1) {
+    // Section not present: no-op
+    if (context.flags.format === 'json') {
+      context.output.out({
+        technology,
+        action: 'none',
+        message: `No managed section for "${technology}" found in .gitignore.`
+      });
+    } else {
+      context.output.info(`No managed section for "${technology}" found in .gitignore.`);
+    }
+    return;
+  }
+
+  if (startIndex === -1 || endIndex === -1 || endIndex <= startIndex) {
+    // Only one marker found or end before start: corrupted state
+    context.output.info(`Warning: Found partial or corrupted markers for "${technology}" in .gitignore. Please fix manually.`);
+    return;
+  }
+
+  // Step D: Remove the section (start through end marker, inclusive)
+  const before = lines.slice(0, startIndex);
+  let after = lines.slice(endIndex + 1);
+
+  // Clean up one trailing blank line after the end marker
+  if (after.length > 0 && after[0].trim() === '') {
+    after = after.slice(1);
+  }
+
+  let newLines = [...before, ...after];
+
+  // Build the updated content
+  let updatedContent = newLines.join('\n');
+
+  // Step E: If the file is now empty (only whitespace), delete it
+  if (updatedContent.trim() === '') {
+    if (context.flags.dryRun) {
+      if (context.flags.format === 'json') {
+        context.output.out({
+          technology,
+          action: 'removed',
+          path: gitignorePath,
+          fileDeleted: true,
+          dryRun: true
+        });
+      } else {
+        context.output.info(`[dry-run] Would remove ${technology} patterns from .gitignore and delete the empty file`);
+      }
+      return;
+    }
+
+    fs.unlinkSync(gitignorePath);
+
+    if (context.flags.format === 'json') {
+      context.output.out({
+        technology,
+        action: 'removed',
+        path: gitignorePath,
+        fileDeleted: true
+      });
+    } else {
+      context.output.info(`Removed ${technology} patterns from .gitignore (file deleted -- was empty)`);
+    }
+    return;
+  }
+
+  // Make sure the file ends with a trailing newline
+  if (!updatedContent.endsWith('\n')) {
+    updatedContent += '\n';
+  }
+
+  // Handle --dry-run
+  if (context.flags.dryRun) {
+    if (context.flags.format === 'json') {
+      context.output.out({
+        technology,
+        action: 'removed',
+        path: gitignorePath,
+        fileDeleted: false,
+        dryRun: true
+      });
+    } else {
+      context.output.info(`[dry-run] Would remove ${technology} patterns from .gitignore`);
+    }
+    return;
+  }
+
+  // Step E: Write the result
+  fs.writeFileSync(gitignorePath, updatedContent);
+
+  // Step F: Output the result
+  if (context.flags.format === 'json') {
+    context.output.out({
+      technology,
+      action: 'removed',
+      path: gitignorePath,
+      fileDeleted: false
+    });
+  } else {
+    context.output.info(`Removed ${technology} patterns from .gitignore`);
+  }
+}
+
+module.exports = { meta, run };

package/src/commands/ignore/show.js

@@ -0,0 +1,169 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { MARKER_START_PREFIX, MARKER_END_PREFIX } = require('./markers');
+
+const meta = {
+  description: 'Show managed gitignore sections in the current directory',
+  arguments: [],
+  flags: [
+    { name: 'path', description: 'Target directory (defaults to current directory)', type: 'string', default: '.' }
+  ]
+};
+
+/**
+ * Scans the .gitignore in the target directory and reports which
+ * DevUtils-managed sections are present, including the technology name,
+ * pattern line count, and line range for each section. Also counts
+ * unmanaged lines (lines outside any DevUtils section that are not blank
+ * or comments).
+ *
+ * @param {object} args - Parsed command arguments ({ positional, flags }).
+ * @param {object} context - The DevUtils context object.
+ */
+async function run(args, context) {
+  // Step A: Resolve the .gitignore path
+  const flagPath = args.flags.path || '.';
+  const gitignorePath = path.resolve(flagPath, '.gitignore');
+
+  // Step B: Read the file
+  if (!fs.existsSync(gitignorePath)) {
+    if (context.flags.format === 'json') {
+      context.output.out({
+        path: gitignorePath,
+        sections: [],
+        count: 0,
+        unmanagedLines: 0,
+        message: `No .gitignore found at ${path.resolve(flagPath)}.`
+      });
+    } else {
+      context.output.info(`No .gitignore found at ${path.resolve(flagPath)}.`);
+    }
+    return;
+  }
+
+  const content = fs.readFileSync(gitignorePath, 'utf8');
+  const lines = content.split(/\r?\n/);
+
+  // Step C: Parse managed sections
+  const sections = [];
+  const managedLineIndices = new Set();
+  let i = 0;
+
+  while (i < lines.length) {
+    const trimmedLine = lines[i].trim();
+
+    if (trimmedLine.startsWith(MARKER_START_PREFIX)) {
+      // Found a start marker -- extract the technology name
+      const technology = trimmedLine.slice(MARKER_START_PREFIX.length);
+      const startLine = i + 1; // 1-indexed
+      managedLineIndices.add(i);
+
+      // Find the corresponding end marker
+      const expectedEnd = `# <<< devutils:${technology}`;
+      let endIdx = -1;
+
+      for (let j = i + 1; j < lines.length; j++) {
+        if (lines[j].trim() === expectedEnd) {
+          endIdx = j;
+          break;
+        }
+      }
+
+      if (endIdx !== -1) {
+        // Mark all lines in this section as managed
+        for (let k = i; k <= endIdx; k++) {
+          managedLineIndices.add(k);
+        }
+
+        const patternLineCount = endIdx - i - 1; // lines between markers
+        const endLine = endIdx + 1; // 1-indexed
+
+        sections.push({
+          technology,
+          lines: patternLineCount,
+          startLine,
+          endLine
+        });
+
+        i = endIdx + 1;
+      } else {
+        // Orphaned start marker -- no matching end
+        sections.push({
+          technology,
+          lines: null,
+          startLine,
+          endLine: null,
+          error: 'Missing end marker'
+        });
+        i++;
+      }
+    } else if (trimmedLine.startsWith(MARKER_END_PREFIX)) {
+      // Orphaned end marker -- no matching start
+      const technology = trimmedLine.slice(MARKER_END_PREFIX.length);
+      managedLineIndices.add(i);
+      sections.push({
+        technology,
+        lines: null,
+        startLine: null,
+        endLine: i + 1, // 1-indexed
+        error: 'Missing start marker'
+      });
+      i++;
+    } else {
+      i++;
+    }
+  }
+
+  // Step D: Count unmanaged lines (not blank, not comments, not in a section)
+  let unmanagedLines = 0;
+  for (let idx = 0; idx < lines.length; idx++) {
+    if (managedLineIndices.has(idx)) continue;
+    const trimmed = lines[idx].trim();
+    if (trimmed === '') continue;
+    if (trimmed.startsWith('#')) continue;
+    unmanagedLines++;
+  }
+
+  // Step E: Build the result
+  const result = {
+    path: gitignorePath,
+    sections,
+    count: sections.length,
+    unmanagedLines
+  };
+
+  // Step F: Format the output
+  if (context.flags.format === 'json') {
+    context.output.out(result);
+  } else {
+    if (sections.length === 0) {
+      context.output.info('No DevUtils-managed sections found in .gitignore.');
+    } else {
+      // Calculate padding for aligned columns
+      const maxNameLength = Math.max(...sections.map(s => s.technology.length));
+      const maxLinesLength = Math.max(...sections.map(s => s.lines !== null ? String(s.lines).length : 1));
+
+      context.output.info('Managed sections in .gitignore:');
+      for (const section of sections) {
+        if (section.error) {
+          const paddedName = section.technology.padEnd(maxNameLength + 2);
+          context.output.info(`  ${paddedName}[${section.error}]`);
+        } else {
+          const paddedName = section.technology.padEnd(maxNameLength + 2);
+          const paddedLines = String(section.lines).padStart(maxLinesLength);
+          context.output.info(`  ${paddedName}${paddedLines} patterns  (lines ${section.startLine}-${section.endLine})`);
+        }
+      }
+      context.output.info('');
+      context.output.info(`${sections.length} managed section${sections.length === 1 ? '' : 's'}.`);
+    }
+
+    if (unmanagedLines > 0) {
+      context.output.info(`Plus ${unmanagedLines} unmanaged line${unmanagedLines === 1 ? '' : 's'}.`);
+    }
+  }
+}
+
+module.exports = { meta, run };

package/src/commands/machine/detect.js

@@ -0,0 +1,122 @@
+'use strict';
+
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Formats a byte count into a human-readable string (e.g., "16.0 GB").
+ * Rounds to one decimal place for clarity.
+ *
+ * @param {number} bytes - The number of bytes to format.
+ * @returns {string} A human-readable size string like "16.0 GB".
+ */
+function formatBytes(bytes) {
+  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+  let i = 0;
+  let value = bytes;
+  while (value >= 1024 && i < units.length - 1) {
+    value /= 1024;
+    i++;
+  }
+  return `${value.toFixed(1)} ${units[i]}`;
+}
+
+const meta = {
+  description: 'Detect the current machine\'s OS, architecture, package managers, and capabilities.',
+  arguments: [],
+  flags: []
+};
+
+/**
+ * Detects the current machine's hardware and OS details, then writes
+ * the profile to ~/.devutils/machines/current.json.
+ *
+ * Uses context.platform.detect() for OS type, then layers on hostname,
+ * CPU count, memory, available package managers, and OS version info
+ * from Node.js built-in modules and shell commands.
+ *
+ * @param {object} args - Parsed command arguments (none expected).
+ * @param {object} context - The CLI context object with platform, shell, output, errors.
+ */
+async function run(args, context) {
+  // Step 1: Get base platform detection
+  const platform = context.platform.detect();
+
+  // Step 2: Gather hardware and system info from Node.js os module
+  const hostname = os.hostname();
+  const cpuCount = os.cpus().length;
+  const totalMemory = os.totalmem();
+  const arch = os.arch();
+  const osRelease = os.release();
+
+  // Step 3: Detect which package managers are installed on this machine
+  const packageManagers = [];
+  const candidates = ['brew', 'apt', 'snap', 'dnf', 'yum', 'choco', 'winget', 'npm', 'yarn', 'pnpm'];
+
+  for (const pm of candidates) {
+    if (context.shell.commandExists(pm)) {
+      packageManagers.push(pm);
+    }
+  }
+
+  // Step 4: Get OS-specific version and name info
+  let osVersion = osRelease;
+  let osName = platform.type;
+
+  try {
+    if (platform.type === 'macos') {
+      const result = await context.shell.exec('sw_vers -productVersion');
+      if (result.exitCode === 0 && result.stdout) {
+        osVersion = result.stdout.trim();
+      }
+      osName = 'macOS';
+    } else if (['ubuntu', 'raspbian', 'amazon-linux'].includes(platform.type)) {
+      const releaseFile = fs.readFileSync('/etc/os-release', 'utf8');
+      const nameMatch = releaseFile.match(/^PRETTY_NAME="?(.+?)"?$/m);
+      if (nameMatch) {
+        osName = nameMatch[1];
+      }
+      const versionMatch = releaseFile.match(/^VERSION_ID="?(.+?)"?$/m);
+      if (versionMatch) {
+        osVersion = versionMatch[1];
+      }
+    }
+  } catch (err) {
+    // Keep defaults if detection fails
+  }
+
+  // Step 5: Build the machine profile object
+  const machineProfile = {
+    hostname: hostname,
+    os: {
+      type: platform.type,
+      name: osName,
+      version: osVersion,
+      kernel: osRelease
+    },
+    arch: arch,
+    cpu: {
+      count: cpuCount,
+      model: os.cpus()[0] ? os.cpus()[0].model : 'unknown'
+    },
+    memory: {
+      total: totalMemory,
+      totalHuman: formatBytes(totalMemory)
+    },
+    packageManagers: packageManagers,
+    detectedAt: new Date().toISOString()
+  };
+
+  // Step 6: Write the profile to disk (idempotent — overwrites if exists)
+  const MACHINES_DIR = path.join(os.homedir(), '.devutils', 'machines');
+  const CURRENT_FILE = path.join(MACHINES_DIR, 'current.json');
+
+  fs.mkdirSync(MACHINES_DIR, { recursive: true });
+  fs.writeFileSync(CURRENT_FILE, JSON.stringify(machineProfile, null, 2) + '\n');
+
+  // Step 7: Output the result
+  context.output.out(machineProfile);
+}
+
+module.exports = { meta, run };

package/src/commands/machine/index.js

@@ -0,0 +1,14 @@
+/**
+ * Machine service registration.
+ * Machine profiles and detection.
+ */
+module.exports = {
+  name: 'machine',
+  description: 'Machine profiles and detection',
+  commands: {
+    detect: () => require('./detect'),
+    show:   () => require('./show'),
+    set:    () => require('./set'),
+    list:   () => require('./list'),
+  }
+};

package/src/commands/machine/list.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const meta = {
+  description: 'List all known machine profiles.',
+  arguments: [],
+  flags: []
+};
+
+/**
+ * Lists all machine profiles stored in ~/.devutils/machines/.
+ * Reads every .json file in the directory and builds a summary for each,
+ * including hostname, OS, architecture, and detection timestamp.
+ * The current machine (current.json) is marked in the output.
+ *
+ * Right now this will only show the local machine. When backup/sync is
+ * built, profiles from other computers will also appear here.
+ *
+ * @param {object} args - Parsed command arguments (none expected).
+ * @param {object} context - The CLI context object with output and errors.
+ */
+async function run(args, context) {
+  const MACHINES_DIR = path.join(os.homedir(), '.devutils', 'machines');
+
+  // Check if the machines directory exists
+  if (!fs.existsSync(MACHINES_DIR)) {
+    context.errors.throwError(404, 'No machine profiles found. Run "dev machine detect" first.', 'machine');
+    return;
+  }
+
+  // Find all JSON files in the machines directory
+  const files = fs.readdirSync(MACHINES_DIR).filter(f => f.endsWith('.json'));
+
+  if (files.length === 0) {
+    context.errors.throwError(404, 'No machine profiles found. Run "dev machine detect" first.', 'machine');
+    return;
+  }
+
+  // Load each profile and build a summary
+  const machines = [];
+
+  for (const file of files) {
+    try {
+      const raw = fs.readFileSync(path.join(MACHINES_DIR, file), 'utf8');
+      const profile = JSON.parse(raw);
+
+      machines.push({
+        file: file,
+        current: file === 'current.json',
+        hostname: profile.hostname || 'unknown',
+        os: profile.os ? `${profile.os.name} ${profile.os.version}` : 'unknown',
+        arch: profile.arch || 'unknown',
+        detectedAt: profile.detectedAt || 'unknown'
+      });
+    } catch (err) {
+      // Don't crash on corrupted files — show them as error entries
+      machines.push({
+        file: file,
+        current: file === 'current.json',
+        hostname: 'error',
+        os: `Failed to read: ${err.message}`,
+        arch: 'unknown',
+        detectedAt: 'unknown'
+      });
+    }
+  }
+
+  context.output.out(machines);
+}
+
+module.exports = { meta, run };

package/src/commands/machine/set.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const meta = {
+  description: 'Set a value in the current machine profile.',
+  arguments: [
+    { name: 'key', required: true, description: 'Dot-notation path to the value (e.g., nickname, os.version)' },
+    { 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' }
+  ]
+};
+
+/**
+ * Updates a single value in the current machine profile by dot-notation key.
+ * Reads ~/.devutils/machines/current.json, sets the value at the given path,
+ * and writes the file back. Preserves all other existing fields.
+ *
+ * Supports type coercion for simple values: "true"/"false" become booleans,
+ * "null" becomes null, numeric strings become numbers. Use --json for
+ * structured values like arrays or objects.
+ *
+ * @param {object} args - Parsed command arguments with positional[0]=key, positional[1]=value.
+ * @param {object} context - The CLI context object with output and errors.
+ */
+async function run(args, context) {
+  const key = args.positional[0];
+  const rawValue = args.positional[1];
+  const jsonValue = args.flags.json;
+
+  // Validate required arguments
+  if (!key) {
+    context.errors.throwError(400, 'Missing required argument: <key>. Example: dev machine set nickname "my-laptop"', 'machine');
+    return;
+  }
+
+  if (!rawValue && rawValue !== '' && !jsonValue) {
+    context.errors.throwError(400, 'Missing value. Provide a value or use --json for structured data.', 'machine');
+    return;
+  }
+
+  if (rawValue && jsonValue) {
+    context.errors.throwError(400, 'Provide either a positional value or --json, not both.', 'machine');
+    return;
+  }
+
+  // Parse the value with type coercion
+  let value;
+
+  if (jsonValue) {
+    try {
+      value = JSON.parse(jsonValue);
+    } catch (err) {
+      context.errors.throwError(400, `Invalid JSON: ${err.message}`, 'machine');
+      return;
+    }
+  } else {
+    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 the existing machine profile
+  const CURRENT_FILE = path.join(os.homedir(), '.devutils', 'machines', 'current.json');
+
+  if (!fs.existsSync(CURRENT_FILE)) {
+    context.errors.throwError(404, 'No machine profile found. Run "dev machine detect" first.', 'machine');
+    return;
+  }
+
+  const raw = fs.readFileSync(CURRENT_FILE, 'utf8');
+  const profile = JSON.parse(raw);
+
+  // Walk the dot-notation path and set the value
+  const parts = key.split('.');
+  let target = profile;
+
+  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 the updated profile back to disk
+  fs.writeFileSync(CURRENT_FILE, JSON.stringify(profile, null, 2) + '\n');
+  context.output.out({ key: key, value: value });
+}
+
+module.exports = { meta, run };

package/src/commands/machine/show.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const meta = {
+  description: 'Display the current machine profile.',
+  arguments: [],
+  flags: []
+};
+
+/**
+ * Reads the current machine profile from ~/.devutils/machines/current.json
+ * and displays it. If the file does not exist, tells the user to run
+ * "dev machine detect" first.
+ *
+ * @param {object} args - Parsed command arguments (none expected).
+ * @param {object} context - The CLI context object with output and errors.
+ */
+async function run(args, context) {
+  const CURRENT_FILE = path.join(os.homedir(), '.devutils', 'machines', 'current.json');
+
+  if (!fs.existsSync(CURRENT_FILE)) {
+    context.errors.throwError(404, 'No machine profile found. Run "dev machine detect" first.', 'machine');
+    return;
+  }
+
+  const raw = fs.readFileSync(CURRENT_FILE, 'utf8');
+  const profile = JSON.parse(raw);
+
+  context.output.out(profile);
+}
+
+module.exports = { meta, run };