@f12r/f12r 1.0.0

package/commands/doctor.js

@@ -0,0 +1,26 @@
+const { getSystemStatus } = require('../utils/checker');
+const { heading, info, success, error, warning, blank } = require('../utils/logger');
+
+async function runDoctor() {
+  heading('f12r doctor');
+  info('🔍 Checking system...');
+
+  const results = await getSystemStatus();
+  blank();
+
+  results.forEach((tool) => {
+    if (tool.installed) {
+      success(`✅ ${tool.label}: Installed${tool.version ? ` (${tool.version})` : ''}`);
+      return;
+    }
+
+    if (tool.optional) {
+      warning(`❌ ${tool.label}: Not Installed (optional)`);
+      return;
+    }
+
+    error(`❌ ${tool.label}: Not Installed`);
+  });
+}
+
+module.exports = runDoctor;

package/commands/setup.js

@@ -0,0 +1,48 @@
+const { TOOLS, getSystemStatus } = require('../utils/checker');
+const { ensureHomebrewInstalled, installTool, installVSCodeExtensions } = require('../utils/installer');
+const { confirmInstallTool, confirmInstallExtensions } = require('../utils/prompts');
+const { heading, info, success, warning, blank } = require('../utils/logger');
+
+async function runSetup(options = {}) {
+  heading('f12r setup');
+  info('🔍 Checking system...');
+
+  await ensureHomebrewInstalled();
+
+  const results = await getSystemStatus();
+  const missingTools = results.filter((tool) => !tool.installed && tool.key !== 'brew');
+
+  if (!missingTools.length) {
+    success('✅ All core tools are already installed.');
+  } else {
+    for (const tool of missingTools) {
+      const shouldInstall = options.all ? true : await confirmInstallTool(tool.label);
+
+      if (!shouldInstall) {
+        warning(`Skipped ${tool.label}.`);
+        continue;
+      }
+
+      await installTool(tool.key);
+    }
+  }
+
+  const codeStatus = await TOOLS.code.check();
+  if (!codeStatus.installed) {
+    warning('VS Code extensions were skipped because the `code` command is not available.');
+    return;
+  }
+
+  const shouldInstallExtensions = options.all ? true : await confirmInstallExtensions();
+
+  if (!shouldInstallExtensions) {
+    info('VS Code extensions skipped.');
+    return;
+  }
+
+  await installVSCodeExtensions();
+  blank();
+  success('✅ Setup complete.');
+}
+
+module.exports = runSetup;

package/commands/uninstall.js

@@ -0,0 +1,31 @@
+const { getManagedTools } = require('../utils/checker');
+const { uninstallTool } = require('../utils/installer');
+const { chooseToolToUninstall, confirmUninstallTool } = require('../utils/prompts');
+const { heading, info, warning, success } = require('../utils/logger');
+
+async function runUninstall() {
+  heading('f12r uninstall');
+  info('🔍 Checking installed removable tools...');
+
+  const removableTools = await getManagedTools();
+  const installedTools = removableTools.filter((tool) => tool.installed);
+
+  if (!installedTools.length) {
+    warning('No supported tools are currently installed via detectable commands.');
+    return;
+  }
+
+  const selectedToolKey = await chooseToolToUninstall(installedTools);
+  const selectedTool = installedTools.find((tool) => tool.key === selectedToolKey);
+  const shouldUninstall = await confirmUninstallTool(selectedTool.label);
+
+  if (!shouldUninstall) {
+    warning(`Cancelled uninstall for ${selectedTool.label}.`);
+    return;
+  }
+
+  await uninstallTool(selectedTool.key);
+  success(`✅ ${selectedTool.label} uninstall flow finished.`);
+}
+
+module.exports = runUninstall;

package/index.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const runDoctor = require('./commands/doctor');
+const runSetup = require('./commands/setup');
+const runUninstall = require('./commands/uninstall');
+const { error } = require('./utils/logger');
+const packageJson = require('./package.json');
+
+const program = new Command();
+
+program
+  .name('f12r')
+  .description('Set up and manage a macOS development environment.')
+  .version(packageJson.version, '-v, --version', 'Show the current f12r version');
+
+program
+  .command('doctor')
+  .description('Check installed development tools and their versions')
+  .action(async () => {
+    try {
+      await runDoctor();
+    } catch (err) {
+      error(err.message);
+      process.exitCode = 1;
+    }
+  });
+
+program
+  .command('setup')
+  .description('Interactively install missing development tools')
+  .option('-a, --all', 'Install all missing tools without prompting')
+  .action(async (options) => {
+    try {
+      await runSetup(options);
+    } catch (err) {
+      error(err.message);
+      process.exitCode = 1;
+    }
+  });
+
+program
+  .command('uninstall')
+  .description('Remove an installed development tool')
+  .action(async () => {
+    try {
+      await runUninstall();
+    } catch (err) {
+      error(err.message);
+      process.exitCode = 1;
+    }
+  });
+
+program.showHelpAfterError('(run with --help for usage information)');
+
+program.parseAsync(process.argv);

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@f12r/f12r",
+  "version": "1.0.0",
+  "description": "A macOS developer environment setup and management CLI.",
+  "main": "index.js",
+  "bin": {
+    "f12r": "index.js"
+  },
+  "scripts": {
+    "doctor": "node index.js doctor",
+    "setup": "node index.js setup",
+    "uninstall": "node index.js uninstall"
+  },
+  "keywords": [
+    "cli",
+    "macos",
+    "developer-tools",
+    "homebrew",
+    "setup"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "execa": "^5.1.1",
+    "inquirer": "^8.2.6",
+    "ora": "^5.4.1"
+  }
+}

package/utils/checker.js

@@ -0,0 +1,123 @@
+const execa = require('execa');
+
+async function commandExists(command) {
+  try {
+    await execa('which', [command]);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+async function getVersion(command, args = ['--version']) {
+  try {
+    const { stdout } = await execa(command, args);
+    const firstLine = stdout.split('\n').find(Boolean);
+    return firstLine ? firstLine.trim() : null;
+  } catch (err) {
+    return null;
+  }
+}
+
+async function checkToolWithVersion({ key, label, command, versionArgs, optional }) {
+  const installed = await commandExists(command);
+
+  return {
+    key,
+    label,
+    command,
+    optional: Boolean(optional),
+    installed,
+    version: installed ? await getVersion(command, versionArgs) : null
+  };
+}
+
+const TOOL_DEFINITIONS = [
+  {
+    key: 'brew',
+    label: 'Homebrew',
+    command: 'brew',
+    versionArgs: ['--version']
+  },
+  {
+    key: 'git',
+    label: 'Git',
+    command: 'git',
+    versionArgs: ['--version']
+  },
+  {
+    key: 'node',
+    label: 'Node.js',
+    command: 'node',
+    versionArgs: ['--version']
+  },
+  {
+    key: 'npm',
+    label: 'npm',
+    command: 'npm',
+    versionArgs: ['--version']
+  },
+  {
+    key: 'docker',
+    label: 'Docker',
+    command: 'docker',
+    versionArgs: ['--version'],
+    optional: true
+  },
+  {
+    key: 'code',
+    label: 'VS Code',
+    command: 'code',
+    versionArgs: ['--version']
+  }
+];
+
+const TOOLS = {
+  brew: {
+    brewName: 'brew',
+    installType: 'formula',
+    check: () => checkToolWithVersion(TOOL_DEFINITIONS[0])
+  },
+  git: {
+    brewName: 'git',
+    installType: 'formula',
+    check: () => checkToolWithVersion(TOOL_DEFINITIONS[1])
+  },
+  node: {
+    brewName: 'node',
+    installType: 'formula',
+    check: () => checkToolWithVersion(TOOL_DEFINITIONS[2])
+  },
+  npm: {
+    brewName: null,
+    installType: null,
+    check: () => checkToolWithVersion(TOOL_DEFINITIONS[3])
+  },
+  docker: {
+    brewName: 'docker',
+    installType: 'cask',
+    check: () => checkToolWithVersion(TOOL_DEFINITIONS[4])
+  },
+  code: {
+    brewName: 'visual-studio-code',
+    installType: 'cask',
+    check: () => checkToolWithVersion(TOOL_DEFINITIONS[5])
+  }
+};
+
+async function getSystemStatus() {
+  return Promise.all(TOOL_DEFINITIONS.map((tool) => checkToolWithVersion(tool)));
+}
+
+async function getManagedTools() {
+  const keys = ['git', 'node', 'docker', 'code'];
+  const tools = await Promise.all(keys.map((key) => TOOLS[key].check()));
+  return tools;
+}
+
+module.exports = {
+  TOOLS,
+  commandExists,
+  getSystemStatus,
+  getManagedTools
+};

package/utils/installer.js

@@ -0,0 +1,125 @@
+const execa = require('execa');
+const ora = require('ora');
+const { TOOLS } = require('./checker');
+const { warning, info } = require('./logger');
+
+const VS_CODE_EXTENSIONS = [
+  'esbenp.prettier-vscode',
+  'dbaeumer.vscode-eslint',
+  'GitHub.copilot'
+];
+
+async function runBrew(args) {
+  return execa('brew', args, { stdio: 'pipe' });
+}
+
+async function ensureHomebrewInstalled() {
+  const brewStatus = await TOOLS.brew.check();
+
+  if (brewStatus.installed) {
+    return;
+  }
+
+  const spinner = ora('🚀 Installing Homebrew...').start();
+
+  try {
+    await execa(
+      '/bin/bash',
+      [
+        '-c',
+        '$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)'
+      ],
+      {
+        env: {
+          ...process.env,
+          NONINTERACTIVE: '1'
+        },
+        shell: false,
+        stdio: 'pipe'
+      }
+    );
+    spinner.succeed('✅ Homebrew installed successfully');
+  } catch (err) {
+    spinner.fail('❌ Failed to install Homebrew');
+    throw new Error(formatCommandError(err));
+  }
+}
+
+async function installTool(toolKey) {
+  const tool = TOOLS[toolKey];
+
+  if (!tool || !tool.brewName) {
+    throw new Error(`Unsupported tool: ${toolKey}`);
+  }
+
+  const spinner = ora(`🚀 Installing ${toolKey === 'code' ? 'VS Code' : capitalize(toolKey)}...`).start();
+
+  try {
+    if (tool.installType === 'cask') {
+      await runBrew(['install', '--cask', tool.brewName]);
+    } else {
+      await runBrew(['install', tool.brewName]);
+    }
+
+    spinner.succeed(`✅ ${toolKey === 'code' ? 'VS Code' : capitalize(toolKey)} installed successfully`);
+  } catch (err) {
+    spinner.fail(`❌ Failed to install ${toolKey === 'code' ? 'VS Code' : capitalize(toolKey)}`);
+    throw new Error(formatCommandError(err));
+  }
+}
+
+async function uninstallTool(toolKey) {
+  const tool = TOOLS[toolKey];
+
+  if (!tool || !tool.brewName) {
+    throw new Error(`Unsupported tool: ${toolKey}`);
+  }
+
+  const spinner = ora(`🧹 Uninstalling ${toolKey === 'code' ? 'VS Code' : capitalize(toolKey)}...`).start();
+
+  try {
+    if (tool.installType === 'cask') {
+      await runBrew(['uninstall', '--cask', tool.brewName]);
+    } else {
+      await runBrew(['uninstall', tool.brewName]);
+    }
+
+    spinner.succeed(`✅ ${toolKey === 'code' ? 'VS Code' : capitalize(toolKey)} removed successfully`);
+  } catch (err) {
+    spinner.fail(`❌ Failed to uninstall ${toolKey === 'code' ? 'VS Code' : capitalize(toolKey)}`);
+    throw new Error(formatCommandError(err));
+  }
+}
+
+async function installVSCodeExtensions() {
+  info('🚀 Installing VS Code extensions...');
+
+  for (const extension of VS_CODE_EXTENSIONS) {
+    const spinner = ora(`Installing ${extension}...`).start();
+
+    try {
+      await execa('code', ['--install-extension', extension], { stdio: 'pipe' });
+      spinner.succeed(`✅ Installed ${extension}`);
+    } catch (err) {
+      spinner.fail(`❌ Failed to install ${extension}`);
+      warning(formatCommandError(err));
+    }
+  }
+}
+
+function formatCommandError(err) {
+  const output = err.stderr || err.stdout || err.shortMessage || err.message;
+  return output.trim();
+}
+
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+module.exports = {
+  VS_CODE_EXTENSIONS,
+  ensureHomebrewInstalled,
+  installTool,
+  uninstallTool,
+  installVSCodeExtensions
+};

package/utils/logger.js

@@ -0,0 +1,34 @@
+const chalk = require('chalk');
+
+function heading(message) {
+  console.log(chalk.cyan.bold(message));
+}
+
+function info(message) {
+  console.log(chalk.blue(message));
+}
+
+function success(message) {
+  console.log(chalk.green(message));
+}
+
+function warning(message) {
+  console.log(chalk.yellow(message));
+}
+
+function error(message) {
+  console.error(chalk.red(message));
+}
+
+function blank() {
+  console.log('');
+}
+
+module.exports = {
+  heading,
+  info,
+  success,
+  warning,
+  error,
+  blank
+};

package/utils/prompts.js

@@ -0,0 +1,63 @@
+const inquirer = require('inquirer');
+
+async function confirmInstallTool(toolLabel) {
+  const { shouldInstall } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'shouldInstall',
+      message: `Install ${toolLabel}?`,
+      default: true
+    }
+  ]);
+
+  return shouldInstall;
+}
+
+async function confirmInstallExtensions() {
+  const { shouldInstallExtensions } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'shouldInstallExtensions',
+      message: 'Install VS Code extensions?',
+      default: true
+    }
+  ]);
+
+  return shouldInstallExtensions;
+}
+
+async function chooseToolToUninstall(installedTools) {
+  const { tool } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'tool',
+      message: 'Which tool would you like to remove?',
+      choices: installedTools.map((installedTool) => ({
+        name: installedTool.label,
+        value: installedTool.key
+      }))
+    }
+  ]);
+
+  return tool;
+}
+
+async function confirmUninstallTool(toolLabel) {
+  const { shouldUninstall } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'shouldUninstall',
+      message: `Uninstall ${toolLabel}?`,
+      default: false
+    }
+  ]);
+
+  return shouldUninstall;
+}
+
+module.exports = {
+  confirmInstallTool,
+  confirmInstallExtensions,
+  chooseToolToUninstall,
+  confirmUninstallTool
+};