@crystalplatforms/adm 0.2.3

package/src/setup/catalog.js

@@ -0,0 +1,13 @@
+const data = require('../data/extensions.json');
+
+function loadCatalog() {
+  return data.categories;
+}
+
+function getToolsByCategories(categoryIds) {
+  const categories = loadCatalog();
+  const selected = categories.filter(cat => categoryIds.includes(cat.id));
+  return selected.flatMap(cat => cat.tools);
+}
+
+module.exports = { loadCatalog, getToolsByCategories };

package/src/setup/installer.js

@@ -0,0 +1,192 @@
+const { promisify } = require('util');
+const execAsync = promisify(require('child_process').exec);
+const execSync = require('child_process').execSync;
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+const SCRIPT_URLS = {
+  rustup: 'https://sh.rustup.rs',
+  bun: 'https://bun.sh/install',
+  conda: 'https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh',
+  gcloud: 'https://sdk.cloud.google.com',
+  'azure-cli': 'https://aka.ms/InstallAzureCli',
+  composer: 'https://getcomposer.org/installer',
+  vcpkg: 'https://github.com/microsoft/vcpkg',
+  'oh-my-zsh': 'https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh',
+};
+
+// Ensure npm uses a user-writable directory (fixes EACCES without sudo)
+let _npmFixed = false;
+function ensureNpmPrefix() {
+  if (_npmFixed) return;
+  _npmFixed = true;
+  try {
+    const prefix = execSync('npm config get prefix', { encoding: 'utf8' }).trim();
+    const userPrefix = path.join(os.homedir(), '.npm-global');
+    const userBin = path.join(userPrefix, 'bin');
+    const needsPrefixChange = prefix === '/usr/local' || prefix === '/usr';
+    const needsPathFix = !process.env.PATH.split(':').includes(userBin);
+
+    if (needsPrefixChange) {
+      if (!fs.existsSync(userPrefix)) {
+        fs.mkdirSync(userBin, { recursive: true });
+      }
+      execSync(`npm config set prefix '${userPrefix}'`, { stdio: 'pipe' });
+    }
+
+    // Always ensure PATH is set — even if prefix was already changed before
+    if (needsPathFix || needsPrefixChange) {
+      addToShellPath(userBin);
+    }
+  } catch {
+    // Can't fix — will fail later with helpful message
+  }
+}
+
+// Add directory to PATH in shell config (.zshrc or .bashrc)
+function addToShellPath(dir) {
+  const marker = '# adm-cli npm path';
+  const exportLine = `export PATH="${dir}:\$PATH"  ${marker}`;
+
+  const shellRc = process.env.SHELL && process.env.SHELL.includes('zsh')
+    ? path.join(os.homedir(), '.zshrc')
+    : path.join(os.homedir(), '.bashrc');
+
+  try {
+    let content = '';
+    if (fs.existsSync(shellRc)) {
+      content = fs.readFileSync(shellRc, 'utf8');
+    }
+    // Remove old adm path entries
+    const lines = content.split('\n').filter(l => !l.includes(marker));
+    lines.push(exportLine);
+    fs.writeFileSync(shellRc, lines.join('\n'), 'utf8');
+  } catch {
+    // Can't write to shell rc — user will need to add manually
+  }
+
+  // Also set in current process so subsequent installs find tools
+  process.env.PATH = `${dir}:${process.env.PATH}`;
+}
+
+function getNpmBinPath() {
+  try {
+    const prefix = execSync('npm config get prefix', { encoding: 'utf8' }).trim();
+    return path.join(prefix, 'bin');
+  } catch {
+    return '';
+  }
+}
+
+function getInstallCommand(tool, platform) {
+  const method = tool.installMethod;
+  const id = tool.id;
+
+  const commands = {
+    npm: `npm install -g ${id}@latest`,
+    brew: platform === 'darwin' ? `brew install ${id}` : `sudo apt-get install -y ${id}`,
+    pip: `pip install --upgrade ${id}`,
+    cargo: `cargo install ${id}`,
+    go: `go install ${id}@latest`,
+    gem: `gem install ${id}`,
+    composer: `composer global require ${id}`,
+    dotnet: `dotnet tool install -g ${id}`,
+    script: `curl -fsSL ${SCRIPT_URLS[id] || 'https://example.com/install'} | sh`,
+    nvm: `curl -fsSL https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.4/install.sh | bash`,
+    node: `npm install -g ${id}@latest`,
+    python: `python3 -m pip install --upgrade ${id}`,
+    rustup: `rustup component add ${id}`,
+    apt: `sudo apt-get install -y ${id}`,
+    manual: `# Manual install required for ${id}`,
+  };
+
+  if (method === 'link') {
+    return `echo 'Visit: ${tool.url || tool.id}'`;
+  }
+
+  return commands[method] || `# Unknown install method: ${method}`;
+}
+
+function isToolInstalled(tool, checkFn) {
+  const check = checkFn || execSync;
+  const cmd = tool.command || tool.id;
+  try {
+    check(`command -v ${cmd} >/dev/null 2>&1`, { shell: '/bin/bash', stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function installToolAsync(tool, platform) {
+  if (tool.installMethod === 'link') {
+    return { id: tool.id, name: tool.name, status: 'link', message: `Visit marketplace: ${tool.url || 'N/A'}` };
+  }
+
+  if (isToolInstalled(tool)) {
+    return { id: tool.id, name: tool.name, status: 'skipped', message: 'already installed' };
+  }
+
+  // For npm/node methods, fix permissions first
+  if (tool.installMethod === 'npm' || tool.installMethod === 'node') {
+    ensureNpmPrefix();
+  }
+
+  const cmd = getInstallCommand(tool, platform);
+  try {
+    await execAsync(cmd, { shell: '/bin/bash' });
+    // Refresh PATH so subsequent tools can find this one
+    refreshPath();
+    return { id: tool.id, name: tool.name, status: 'installed', message: 'installed' };
+  } catch (err) {
+    const stderr = err.stderr || '';
+    let hint = '';
+    if (stderr.includes('EACCES')) {
+      hint = 'Fix: npm config set prefix ~/.npm-global && add ~/.npm-global/bin to PATH';
+    }
+    return { id: tool.id, name: tool.name, status: 'failed', error: (stderr.split('\n')[0] || err.message), hint, command: cmd };
+  }
+}
+
+// Refresh PATH by reading shell rc files (picks up new tool paths like ~/.bun/bin)
+function refreshPath() {
+  const home = os.homedir();
+  const extraDirs = [
+    path.join(home, '.npm-global', 'bin'),
+    path.join(home, '.bun', 'bin'),
+    path.join(home, '.cargo', 'bin'),
+    path.join(home, 'go', 'bin'),
+    '/opt/homebrew/bin',
+    '/usr/local/bin',
+  ];
+  for (const dir of extraDirs) {
+    if (fs.existsSync(dir) && !process.env.PATH.split(':').includes(dir)) {
+      process.env.PATH = `${dir}:${process.env.PATH}`;
+    }
+  }
+}
+
+async function installTools(tools, platform, checkFn) {
+  const run = checkFn || execSync;
+  const results = [];
+
+  for (const tool of tools) {
+    if (isToolInstalled(tool, run)) {
+      results.push({ id: tool.id, name: tool.name, status: 'skipped', message: `${tool.name} is already installed` });
+      continue;
+    }
+
+    const cmd = getInstallCommand(tool, platform);
+    try {
+      run(cmd, { shell: '/bin/bash', stdio: 'pipe' });
+      results.push({ id: tool.id, name: tool.name, status: 'installed', message: `${tool.name} installed` });
+    } catch (err) {
+      results.push({ id: tool.id, name: tool.name, status: 'failed', error: err.message });
+    }
+  }
+
+  return results;
+}
+
+module.exports = { getInstallCommand, isToolInstalled, installTools, installToolAsync };

package/src/setup/wizard.js

@@ -0,0 +1,220 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const ora = require('ora');
+const { writeConfig, readConfig } = require('../config');
+const { detectShell } = require('../shell/detector');
+const { isNodeInstalled, installNode, getNodeVersion } = require('../installer/node-installer');
+const { isPnpmInstalled, installPnpm } = require('../installer/package-manager-installer');
+const { configureGit, getCurrentGitConfig } = require('../installer/git-config');
+const { sshKeyExists, generateSshKey, getPublicKey } = require('../installer/ssh-setup');
+const { detectPlatform, isBrewInstalled, installBrew, isAptInstalled, installAptPackages } = require('../installer/system-packages');
+
+async function runSetup(options = {}) {
+  const dry = process.env.ADM_DRY_RUN === '1' || options.dryRun;
+  const shell = detectShell();
+
+  console.log(chalk.cyan('\n  ADM Setup Wizard\n'));
+  console.log(chalk.gray(`  Detected shell: ${shell}`));
+  console.log(chalk.gray(`  Detected OS: ${detectPlatform()}\n`));
+
+  if (dry) {
+    return { dryRun: true, shell, platform: detectPlatform(), planned: getFullPlan() };
+  }
+
+  // Step 1: System package manager
+  const platform = detectPlatform();
+  if (platform === 'darwin' && !isBrewInstalled()) {
+    const { installBrew: wantBrew } = await inquirer.prompt([{
+      type: 'confirm', name: 'installBrew', message: 'Install Homebrew?', default: true,
+    }]);
+    if (wantBrew) {
+      const s = ora('Installing Homebrew...').start();
+      try { await installBrew(); s.succeed('Homebrew installed'); }
+      catch (e) { s.fail(`Homebrew install failed: ${e.message}`); }
+    }
+  } else if (platform === 'linux' && !isAptInstalled()) {
+    const { installApt } = await inquirer.prompt([{
+      type: 'confirm', name: 'installApt', message: 'Install base apt packages (git, curl, build-essential)?', default: true,
+    }]);
+    if (installApt) {
+      const s = ora('Installing apt packages...').start();
+      try { await installAptPackages(); s.succeed('Apt packages installed'); }
+      catch (e) { s.fail(`Apt install failed: ${e.message}`); }
+    }
+  }
+
+  // Step 2: Node.js
+  const nodeStatus = isNodeInstalled();
+  let nodeVersion = nodeStatus.version;
+  if (!nodeStatus.installed) {
+    const { nodeChoice } = await inquirer.prompt([{
+      type: 'list',
+      name: 'nodeChoice',
+      message: 'Node.js is not installed. How would you like to install it?',
+      choices: [
+        { name: 'Install latest LTS (via nvm)', value: 'lts' },
+        { name: 'Install specific version', value: 'custom' },
+        { name: 'Skip Node.js installation', value: 'skip' },
+      ],
+      default: 'lts',
+    }]);
+    let customVersion;
+    if (nodeChoice === 'custom') {
+      ({ customVersion } = await inquirer.prompt([{
+        type: 'input', name: 'customVersion', message: 'Enter Node.js version (e.g. 18.17.0):',
+      }]));
+    }
+    if (nodeChoice !== 'skip') {
+      const s = ora(`Installing Node.js ${nodeChoice === 'custom' ? customVersion : 'LTS'}...`).start();
+      try {
+        await installNode(nodeChoice === 'custom' ? customVersion : '--lts');
+        nodeVersion = getNodeVersion();
+        s.succeed(`Node.js installed: ${nodeVersion}`);
+      } catch (e) {
+        s.fail(`Node.js install failed: ${e.message}`);
+      }
+    }
+  } else {
+    console.log(chalk.green(`  Node.js ${nodeVersion} already installed`));
+  }
+
+  // Step 3: Package managers
+  const pnpmStatus = isPnpmInstalled();
+  if (!pnpmStatus.installed) {
+    const { wantPnpm } = await inquirer.prompt([{
+      type: 'confirm', name: 'wantPnpm', message: 'Install pnpm?', default: true,
+    }]);
+    if (wantPnpm) {
+      const s = ora('Installing pnpm...').start();
+      try { await installPnpm(); s.succeed('pnpm installed'); }
+      catch (e) { s.fail(`pnpm install failed: ${e.message}`); }
+    }
+  } else {
+    console.log(chalk.green(`  pnpm ${pnpmStatus.version} already installed`));
+  }
+
+  // Step 4: Optional tools
+  const { tools } = await inquirer.prompt([{
+    type: 'checkbox',
+    name: 'tools',
+    message: 'Select optional tools to install:',
+    choices: [
+      { name: 'Vite', value: 'vite', checked: false },
+      { name: 'esbuild', value: 'esbuild', checked: false },
+      { name: 'TypeScript (tsc)', value: 'typescript', checked: false },
+      { name: 'Docker (via system pkg)', value: 'docker', checked: false },
+      { name: 'GitHub CLI (gh)', value: 'gh', checked: false },
+    ],
+  }]);
+  if (tools.length > 0) {
+    const s = ora(`Installing: ${tools.join(', ')}...`).start();
+    try {
+      for (const tool of tools) {
+        if (['vite', 'esbuild', 'typescript'].includes(tool)) {
+          const { execSync } = require('child_process');
+          execSync(`npm install -g ${tool}`, { stdio: 'pipe' });
+        } else if (tool === 'docker') {
+          const { installSystemPackage } = require('../installer/system-packages');
+          await installSystemPackage('docker.io');
+        } else if (tool === 'gh') {
+          const { installSystemPackage } = require('../installer/system-packages');
+          await installSystemPackage('gh');
+        }
+      }
+      s.succeed(`Installed: ${tools.join(', ')}`);
+    } catch (e) {
+      s.fail(`Tool install failed: ${e.message}`);
+    }
+  }
+
+  // Step 5: Git config
+  const currentGit = getCurrentGitConfig();
+  const gitAnswers = await inquirer.prompt([
+    {
+      type: 'input', name: 'name', message: 'Git user.name:',
+      default: currentGit.name || undefined,
+    },
+    {
+      type: 'input', name: 'email', message: 'Git user.email:',
+      default: currentGit.email || undefined,
+    },
+    {
+      type: 'confirm', name: 'gpgsign', message: 'Enable GPG commit signing?',
+      default: currentGit.gpgsign === 'true',
+    },
+  ]);
+  await configureGit(gitAnswers);
+
+  // Step 6: SSH key
+  if (!sshKeyExists()) {
+    const { wantSsh } = await inquirer.prompt([{
+      type: 'confirm', name: 'wantSsh', message: 'Generate SSH key (ED25519)?', default: true,
+    }]);
+    if (wantSsh) {
+      const result = generateSshKey(gitAnswers.email || 'adm@local');
+      if (result.skipped) {
+        console.log(chalk.yellow(`  ${result.reason}`));
+      } else {
+        console.log(chalk.green(`  SSH key generated: ${result.keyPath}`));
+        console.log(chalk.gray(`  Public key: ${getPublicKey(result.keyPath).substring(0, 60)}...`));
+      }
+    }
+  } else {
+    console.log(chalk.green('  SSH key already exists'));
+  }
+
+  // Step 7: Dotfiles (optional)
+  const { dotfilesUrl } = await inquirer.prompt([{
+    type: 'input', name: 'dotfilesUrl', message: 'Dotfiles repo URL (leave empty to skip):',
+  }]);
+  if (dotfilesUrl) {
+    const s = ora('Cloning dotfiles...').start();
+    try {
+      const { execSync } = require('child_process');
+      const dotfilesDir = require('path').join(require('os').homedir(), '.adm', 'dotfiles');
+      execSync(`git clone "${dotfilesUrl}" "${dotfilesDir}"`, { stdio: 'pipe' });
+      s.succeed(`Dotfiles cloned to ${dotfilesDir}`);
+    } catch (e) {
+      s.fail(`Dotfiles clone failed: ${e.message}`);
+    }
+  }
+
+  // Step 8: Assistant mode
+  const { assistant } = await inquirer.prompt([{
+    type: 'confirm', name: 'assistant', message: 'Enable assistant mode?', default: false,
+  }]);
+
+  // Save config
+  const config = {
+    installed: true,
+    setupCompletedAt: new Date().toISOString(),
+    shell,
+    platform,
+    nodeVersion,
+    pnpm: pnpmStatus.installed || (await isPnpmInstalled()).installed,
+    tools,
+    git: { name: gitAnswers.name, email: gitAnswers.email, gpgsign: gitAnswers.gpgsign },
+    assistant,
+    dotfiles: dotfilesUrl || null,
+  };
+  await writeConfig(config);
+
+  console.log(chalk.cyan('\n  Setup complete! Config saved to ~/.adm/config.json\n'));
+  return config;
+}
+
+function getFullPlan() {
+  return [
+    'Detect and install system package manager (brew/apt)',
+    'Install Node.js via nvm',
+    'Install pnpm',
+    'Install optional tools (Vite, esbuild, TypeScript, Docker, gh)',
+    'Configure git (user.name, user.email, gpgsign)',
+    'Generate SSH key (ED25519)',
+    'Clone dotfiles repo',
+    'Enable assistant mode',
+    'Save config to ~/.adm/config.json',
+  ];
+}
+
+module.exports = { runSetup };

package/src/shell/detector.js

@@ -0,0 +1,10 @@
+// Minimal shell detector stub for TDD
+function detectShell(env) {
+  env = env || process.env;
+  const shell = env.SHELL || '';
+  if (shell.includes('zsh')) return 'zsh';
+  if (shell.includes('bash')) return 'bash';
+  if (env.TERM_PROGRAM && env.TERM_PROGRAM.includes('Apple_Terminal')) return 'bash';
+  return 'unknown';
+}
+module.exports = { detectShell };