@crystalplatforms/adm 0.2.3

package/src/commands/dotfiles.js

@@ -0,0 +1,72 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const ora = require('ora');
+const child_process = require('child_process');
+const { readConfig, ensureConfigDir } = require('../config');
+const { syncDotfiles } = require('../utils/dotfiles-sync');
+
+/**
+ * /dotfiles sync — clones/pulls dotfiles repo and synchronizes files
+ *
+ * Options:
+ *   repo: string — dotfiles repo URL (overrides config)
+ *   copy: boolean — copy instead of symlinking
+ *   only: string[] — file filter (e.g. ['bashrc', 'zshrc'])
+ */
+async function syncDotfilesCommand(options = {}) {
+  const configDir = process.env.ADM_CONFIG_DIR || path.join(require('os').homedir(), '.adm');
+  const dotfilesDir = path.join(configDir, 'dotfiles');
+
+  // Get repo URL
+  let repoUrl = options.repo;
+  if (!repoUrl) {
+    const config = await readConfig();
+    repoUrl = config?.dotfiles?.repo;
+  }
+  if (!repoUrl) {
+    throw new Error('No dotfiles repo URL. Use --repo or set in config (dotfiles.repo).');
+  }
+
+  // Clone or pull repo
+  const s = ora('Syncing dotfiles...').start();
+  try {
+    if (fs.existsSync(path.join(dotfilesDir, '.git'))) {
+      s.text = 'Pulling updates...';
+      child_process.execSync(`git pull`, { cwd: dotfilesDir, stdio: 'pipe' });
+    } else {
+      // Remove empty directory if it exists
+      if (fs.existsSync(dotfilesDir)) {
+        fs.rmSync(dotfilesDir, { recursive: true, force: true });
+      }
+      s.text = 'Cloning dotfiles repo...';
+      child_process.execSync(`git clone ${repoUrl} ${dotfilesDir}`, { stdio: 'pipe' });
+    }
+    s.succeed('Dotfiles repo ready');
+  } catch (err) {
+    s.fail(`Git error: ${err.message}`);
+    throw err;
+  }
+
+  // Sync files
+  console.log(chalk.bold('\n  Syncing files:'));
+  const result = await syncDotfiles({
+    repo: repoUrl,
+    copy: options.copy,
+    only: options.only,
+  });
+
+  // Summary
+  const total = result.symlinked.length + result.copied.length;
+  console.log(chalk.bold(`\n  Done: ${total} files synced`));
+  if (result.skipped.length > 0) {
+    console.log(chalk.yellow(`  Skipped: ${result.skipped.join(', ')}`));
+  }
+  if (result.errors.length > 0) {
+    console.log(chalk.red(`  Errors: ${result.errors.map(e => e.file).join(', ')}`));
+  }
+
+  return result;
+}
+
+module.exports = { syncDotfilesCommand };

package/src/commands/issue.js

@@ -0,0 +1,80 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const inquirer = require('inquirer');
+const gitlab = require('../integrations/gitlab');
+const { listStoredServices } = require('../utils/keychain');
+
+/**
+ * Lists issues from connected platforms (GitHub + GitLab)
+ * When multiple platforms — interactive selection
+ * When --platform given — skips selection
+ */
+async function listIssues(options = {}) {
+  const services = await listStoredServices();
+
+  if (services.length === 0) {
+    throw new Error('No connected platforms. Run /connect to connect GitHub or GitLab.');
+  }
+
+  // Filter to platforms supporting issues
+  const platforms = services.filter(s => ['github', 'gitlab'].includes(s));
+  if (platforms.length === 0) {
+    throw new Error('No connected platforms. Run /connect to connect GitHub or GitLab.');
+  }
+
+  let platform = options.platform;
+
+  // When --platform given, use it
+  if (!platform) {
+    if (platforms.length === 1) {
+      platform = platforms[0];
+    } else {
+      // Interactive selection
+      const answer = await inquirer.prompt([{
+        type: 'list',
+        name: 'platform',
+        message: 'Which platform to fetch issues from?',
+        choices: platforms.map(p => ({ name: p.charAt(0).toUpperCase() + p.slice(1), value: p })),
+      }]);
+      platform = answer.platform;
+    }
+  }
+
+  const s = ora(`Fetching issues from ${platform}...`).start();
+  try {
+    let issues;
+    if (platform === 'gitlab') {
+      issues = await gitlab.listIssues(options);
+    } else {
+      // GitHub uses search API for issues
+      const github = require('../integrations/github');
+      const octokit = await github.getClient();
+      const { data: user } = await octokit.users.getAuthenticated();
+      const { data } = await octokit.search.issuesAndPullRequests({
+        q: `author:${user.login} is:issue is:open`,
+        sort: 'updated',
+        order: 'desc',
+        per_page: options.limit || 20,
+      });
+      issues = data.items.map(issue => ({
+        iid: issue.number,
+        title: issue.title,
+        state: issue.state,
+        url: issue.html_url,
+        updatedAt: issue.updated_at,
+      }));
+    }
+
+    s.succeed(`Found ${issues.length} issues on ${platform}`);
+    for (const issue of issues) {
+      console.log(`  ${chalk.bold(`#${issue.iid}`)} ${issue.title}`);
+      console.log(`    ${chalk.gray(issue.url)}`);
+    }
+    return issues;
+  } catch (err) {
+    s.fail(err.message);
+    throw err;
+  }
+}
+
+module.exports = { listIssues };

package/src/commands/pr.js

@@ -0,0 +1,55 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const github = require('../integrations/github');
+
+async function listPRs(options = {}) {
+  const s = ora('Fetching pull requests...').start();
+  try {
+    const prs = await github.listPRs(options);
+    s.stop();
+    if (prs.length === 0) {
+      console.log(chalk.yellow('  No open pull requests found.'));
+      return [];
+    }
+    for (const pr of prs) {
+      console.log(
+        `  ${chalk.bold(`#${pr.number}`)} ${pr.title}`,
+        chalk.gray(`(${pr.repo})`),
+        chalk.green(pr.state),
+      );
+      console.log(chalk.gray(`    ${pr.url}`));
+    }
+    return prs;
+  } catch (err) {
+    s.fail(err.message);
+    throw err;
+  }
+}
+
+async function draftPR(title, options = {}) {
+  const s = ora(`Creating draft PR "${title}"...`).start();
+  try {
+    const result = await github.createDraftPR(title, options);
+    s.succeed(`Draft PR #${result.number} created`);
+    console.log(chalk.gray(`  ${result.url}`));
+    return result;
+  } catch (err) {
+    s.fail(err.message);
+    throw err;
+  }
+}
+
+async function commentPR(prNumber, message, options = {}) {
+  const s = ora(`Commenting on PR #${prNumber}...`).start();
+  try {
+    const result = await github.commentOnPR(prNumber, message, options);
+    s.succeed(`Comment added to PR #${prNumber}`);
+    console.log(chalk.gray(`  ${result.url}`));
+    return result;
+  } catch (err) {
+    s.fail(err.message);
+    throw err;
+  }
+}
+
+module.exports = { listPRs, draftPR, commentPR };

package/src/commands/theme.js

@@ -0,0 +1,103 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const { resolveTheme, listThemes } = require('../ui/theme');
+const { readConfig, writeConfig } = require('../config');
+
+/**
+ * /theme — interactive theme selector with live preview.
+ * Arrow keys to browse, Enter to apply, theme saved to ~/.adm/config.json.
+ */
+async function themeCommand() {
+  const config = await readConfig();
+  const currentTheme = config.theme || 'dark';
+  const themes = listThemes();
+
+  // ── Show current theme ────────────────────────────────
+  console.log('');
+  const cur = resolveTheme(config);
+  const cc = cur.colors;
+  console.log(
+    chalk.hex(cc.primary)('  Current: ') +
+    chalk.hex(cc.accent)(cur.name) +
+    chalk.hex(cc.muted)(' (' + currentTheme + ')')
+  );
+  console.log('');
+
+  // ── Build preview for each theme ──────────────────────
+  const choices = themes.map(t => {
+    const c = t.colors;
+    const block = (hex) => chalk.hex(hex)('██');
+    const label =
+      '  ' +
+      block(c.primary) + block(c.accent) + block(c.secondary) +
+      '  ' +
+      chalk.hex(c.primary).bold(t.name.padEnd(10)) +
+      chalk.hex(c.muted)('adm> ') +
+      chalk.hex(c.text)('hello') + ' ' +
+      chalk.hex(c.success)('✓') + ' ' +
+      chalk.hex(c.error)('✗') + ' ' +
+      chalk.hex(c.warning)('⚠');
+
+    return {
+      name: label,
+      value: t.name,
+      short: t.name,
+    };
+  });
+
+  // ── Interactive selection ──────────────────────────────
+  const { selected } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'selected',
+      message: 'Choose a theme:',
+      choices,
+      default: currentTheme,
+      pageSize: themes.length,
+      loop: false,
+    },
+  ]);
+
+  // ── Save to config ────────────────────────────────────
+  if (selected === currentTheme) {
+    const t = resolveTheme({ theme: selected });
+    console.log('');
+    console.log(chalk.hex(t.colors.muted)('  Already using ' + selected + ' theme.'));
+    console.log('');
+    return;
+  }
+
+  const newConfig = { ...config, theme: selected };
+  await writeConfig(newConfig);
+
+  const t = resolveTheme({ theme: selected });
+  const nc = t.colors;
+  console.log('');
+  console.log(
+    chalk.hex(nc.success)('  ✓ Theme saved: ') +
+    chalk.hex(nc.primary).bold(selected)
+  );
+  console.log(
+    chalk.hex(nc.muted)('  ~/.adm/config.json updated') +
+    chalk.hex(nc.text)(' — restart to see changes everywhere.')
+  );
+  console.log('');
+
+  // ── Show preview of new theme ─────────────────────────
+  showPreview(nc, selected);
+}
+
+function showPreview(c, name) {
+  const border = chalk.hex(c.primary);
+  const pad = '                ';
+  console.log('');
+  console.log(border('  ┌──────────────────────────────────┐'));
+  console.log(border('  │ ') + chalk.hex(c.text).bold('  ADM') + chalk.hex(c.muted)(' · ' + name) + pad.slice(0, Math.max(0, 18 - name.length)) + border('│'));
+  console.log(border('  │ ') + chalk.hex(c.muted)('  adm> ') + chalk.hex(c.text)('status') + pad.slice(0, 12) + border('│'));
+  console.log(border('  │ ') + chalk.hex(c.success)('  ✓ All systems go') + pad.slice(0, 10) + border('│'));
+  console.log(border('  │ ') + chalk.hex(c.accent)('  ██ ██') + chalk.hex(c.text)('  12:34') + pad.slice(0, 10) + border('│'));
+  console.log(border('  └──────────────────────────────────┘'));
+  console.log('');
+}
+
+module.exports = { themeCommand };

package/src/commands/uninstall.js

@@ -0,0 +1,72 @@
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+const { spawn } = require('child_process');
+const chalk = require('chalk');
+
+async function uninstall() {
+  const configDir = process.env.ADM_CONFIG_DIR || path.join(os.homedir(), '.adm');
+
+  console.log(chalk.yellow('  Uninstalling ADM CLI...\n'));
+
+  // Remove config directory
+  try {
+    await fs.rm(configDir, { recursive: true, force: true });
+    console.log(chalk.green(`  Removed config directory: ${configDir}`));
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      console.log(chalk.red(`  Failed to remove config: ${err.message}`));
+    }
+  }
+
+  // Uninstall npm package
+  await new Promise((resolve) => {
+    const child = spawn('npm', ['uninstall', '-g', '@crystalgames/adm'], { stdio: 'pipe' });
+    child.on('close', (code) => {
+      if (code === 0) {
+        console.log(chalk.green('  Removed npm package: @crystalgames/adm'));
+      } else {
+        console.log(chalk.yellow('  npm uninstall failed — package may have been installed differently'));
+      }
+      resolve();
+    });
+  });
+
+  // Remove binary (curl-installed)
+  const binaryPath = '/usr/local/bin/adm';
+  try {
+    await fs.rm(binaryPath, { force: true });
+    console.log(chalk.green(`  Removed binary: ${binaryPath}`));
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      console.log(chalk.yellow(`  Could not remove binary: ${err.message}`));
+    }
+  }
+
+  // Remove shell completions references
+  const shell = process.env.SHELL || '';
+  const rcFiles = [];
+  if (shell.includes('bash')) {
+    rcFiles.push(path.join(os.homedir(), '.bashrc'), path.join(os.homedir(), '.bash_profile'));
+  } else if (shell.includes('zsh')) {
+    rcFiles.push(path.join(os.homedir(), '.zshrc'));
+  }
+
+  for (const rc of rcFiles) {
+    try {
+      let content = await fs.readFile(rc, 'utf8');
+      const cleaned = content.split('\n').filter(
+        line => !line.includes('adm completion') && !line.includes('source.*adm'),
+      ).join('\n');
+      if (content !== cleaned) {
+        await fs.writeFile(rc, cleaned, 'utf8');
+        console.log(chalk.green(`  Cleaned ADM references from ${rc}`));
+      }
+    } catch { /* skip missing rc files */ }
+  }
+
+  console.log(chalk.green('\n  ADM CLI fully uninstalled.'));
+  return true;
+}
+
+module.exports = { uninstall };

package/src/commands/upgrade.js

@@ -0,0 +1,114 @@
+const { spawn } = require('child_process');
+const chalk = require('chalk');
+const { version: currentVersion } = require('../../package.json');
+
+const FRAMES = ['◢', '◣', '◤', '◥'];
+
+function createLoader(text) {
+  let i = 0;
+  let active = true;
+  const interval = setInterval(() => {
+    i = (i + 1) % FRAMES.length;
+    process.stdout.write(`\r${chalk.cyan(FRAMES[i])} ${text}`);
+  }, 80);
+
+  return {
+    update(t) { text = t; },
+    succeed(msg) {
+      active = false;
+      clearInterval(interval);
+      process.stdout.write(`\r${chalk.green('✔')} ${msg || text}\n`);
+    },
+    fail(msg) {
+      active = false;
+      clearInterval(interval);
+      process.stdout.write(`\r${chalk.red('✖')} ${msg || text}\n`);
+    },
+    info(msg) {
+      active = false;
+      clearInterval(interval);
+      process.stdout.write(`\r${chalk.yellow('ℹ')} ${msg || text}\n`);
+    },
+    stop() {
+      if (!active) return;
+      active = false;
+      clearInterval(interval);
+      process.stdout.write('\r' + ' '.repeat((text || '').length + 4) + '\r');
+    },
+  };
+}
+
+function runSpawn(cmd, args) {
+  return new Promise((resolve, reject) => {
+    let stdout = '';
+    let stderr = '';
+    const child = spawn(cmd, args, { stdio: 'pipe' });
+    child.stdout.on('data', (data) => { stdout += data.toString(); });
+    child.stderr.on('data', (data) => { stderr += data.toString(); });
+    child.on('close', (code) => {
+      if (code === 0) resolve(stdout.trim());
+      else reject(new Error(stderr.trim() || `Command failed with code ${code}`));
+    });
+  });
+}
+
+async function upgrade() {
+  const spinner = createLoader('Checking for updates...');
+
+  let latestVersion;
+  try {
+    const output = await runSpawn('npm', ['view', '@crystalgames/adm', 'version']);
+    latestVersion = output.split('\n').pop().trim();
+  } catch (err) {
+    spinner.fail('Update check failed');
+    return {
+      output: chalk.red(`Unable to check for updates: ${err.message}`),
+      shouldExit: false,
+      shouldClear: false,
+    };
+  }
+
+  if (latestVersion === currentVersion) {
+    spinner.succeed(chalk.green(`Already up to date (v${currentVersion})`));
+    return {
+      output: '',
+      shouldExit: false,
+      shouldClear: false,
+    };
+  }
+
+  spinner.info(chalk.yellow(`Update available: v${currentVersion} → v${latestVersion}`));
+
+  return {
+    output: `Update to v${latestVersion}? [y/N]`,
+    needsConfirm: true,
+    confirmMessage: `Update available: v${currentVersion} → v${latestVersion}`,
+    async onConfirm() {
+      const installSpinner = createLoader(`Updating to v${latestVersion}...`);
+      try {
+        await runSpawn('npm', ['install', '-g', '@crystalgames/adm@latest']);
+        installSpinner.succeed(chalk.green(`Updated to v${latestVersion}`));
+        return {
+          output: chalk.green(`Restarting...`),
+          shouldRestart: true,
+          shouldExit: false,
+          shouldClear: false,
+        };
+      } catch (err) {
+        installSpinner.fail(chalk.red('Update failed'));
+        return {
+          output: chalk.red(`Update failed: ${err.message}`),
+          shouldExit: false,
+          shouldClear: false,
+        };
+      }
+    },
+    onCancel() {
+      return { output: chalk.gray('Cancelled.'), shouldExit: false, shouldClear: false };
+    },
+    shouldExit: false,
+    shouldClear: false,
+  };
+}
+
+module.exports = { upgrade };

package/src/config/index.js

@@ -0,0 +1,32 @@
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+
+function configDir() {
+  return process.env.ADM_CONFIG_DIR || path.join(os.homedir(), '.adm');
+}
+
+async function ensureConfigDir(dir) {
+  await fs.mkdir(dir, { recursive: true });
+}
+
+async function readConfig() {
+  const dir = configDir();
+  const file = path.join(dir, 'config.json');
+  try {
+    const data = await fs.readFile(file, 'utf8');
+    return JSON.parse(data);
+  } catch (err) {
+    if (err.code === 'ENOENT') return {};
+    throw err;
+  }
+}
+
+async function writeConfig(obj) {
+  const dir = configDir();
+  await ensureConfigDir(dir);
+  const file = path.join(dir, 'config.json');
+  await fs.writeFile(file, JSON.stringify(obj, null, 2), 'utf8');
+}
+
+module.exports = { configDir, readConfig, writeConfig, ensureConfigDir };