dotai-cli 1.0.0

package/src/commands/open.js

@@ -0,0 +1,82 @@
+import chalk from 'chalk';
+import { spawn } from 'child_process';
+import { platform } from 'os';
+import Enquirer from 'enquirer';
+const { prompt } = Enquirer;
+import { listCentralSkills, getCentralSkill } from '../lib/skills.js';
+import { getSkillsRepoDir } from '../lib/paths.js';
+
+/**
+ * Open a skill folder or file in the system default editor/file manager
+ */
+export async function openCommand(skillName, options) {
+  let skill;
+
+  // If no skill name, show interactive picker
+  if (!skillName) {
+    const skills = await listCentralSkills();
+    if (skills.length === 0) {
+      console.log(chalk.yellow('No skills found.'));
+      console.log(`Create one with: ${chalk.cyan('dotai skill create')}\n`);
+      return;
+    }
+
+    const answer = await prompt({
+      type: 'select',
+      name: 'skill',
+      message: 'Select a skill to open:',
+      choices: skills.map(s => ({
+        name: s.name,
+        message: `${s.name} - ${chalk.dim(s.description || 'No description')}`,
+        value: s.name
+      }))
+    });
+    skillName = answer.skill;
+  }
+
+  skill = await getCentralSkill(skillName);
+
+  if (!skill) {
+    console.error(chalk.red(`Skill '${skillName}' not found`));
+    return;
+  }
+
+  const targetPath = options.file ? skill.filePath : skill.path;
+  const openCmd = getOpenCommand();
+
+  console.log(chalk.dim(`Opening: ${targetPath}\n`));
+
+  spawn(openCmd, [targetPath], {
+    detached: true,
+    stdio: 'ignore'
+  }).unref();
+}
+
+/**
+ * Get the platform-specific command to open files/folders
+ */
+function getOpenCommand() {
+  switch (platform()) {
+    case 'darwin':
+      return 'open';
+    case 'win32':
+      return 'explorer';
+    default:
+      return 'xdg-open';
+  }
+}
+
+/**
+ * Open the entire skills repository folder
+ */
+export async function openRepoCommand() {
+  const repoPath = getSkillsRepoDir();
+  const openCmd = getOpenCommand();
+
+  console.log(chalk.dim(`Opening skills repository: ${repoPath}\n`));
+
+  spawn(openCmd, [repoPath], {
+    detached: true,
+    stdio: 'ignore'
+  }).unref();
+}

package/src/commands/sync.js

@@ -0,0 +1,71 @@
+import chalk from 'chalk';
+import Enquirer from 'enquirer';
+const { prompt } = Enquirer;
+import ora from 'ora';
+import { listCentralSkills, installSkill, getSkillInstallStatus } from '../lib/skills.js';
+import { loadConfig } from '../lib/config.js';
+import { providers, getProviderIds } from '../providers/index.js';
+
+export async function syncCommand(options) {
+  console.log(chalk.bold('\n🔄 Sync skills to providers\n'));
+
+  const config = await loadConfig();
+  const skills = await listCentralSkills();
+
+  if (skills.length === 0) {
+    console.log(chalk.yellow('No skills to sync.'));
+    console.log(`Create skills with: ${chalk.cyan('dotai skill create')}\n`);
+    return;
+  }
+
+  // Determine target providers
+  let targetProviders = options.providers
+    ? options.providers.split(',').map(p => p.trim())
+    : config.enabledProviders;
+
+  if (options.all) {
+    targetProviders = getProviderIds();
+  }
+
+  // Determine scope
+  const scope = options.project ? 'project' : 'global';
+
+  console.log(chalk.dim(`Syncing ${skills.length} skill(s) to ${targetProviders.length} provider(s)...\n`));
+
+  const results = {
+    installed: 0,
+    skipped: 0,
+    failed: 0
+  };
+
+  for (const skill of skills) {
+    const spinner = ora(`Syncing ${skill.name}...`).start();
+
+    try {
+      const installResults = await installSkill(skill.name, targetProviders, scope);
+
+      const successes = installResults.filter(r => r.success).length;
+      const failures = installResults.filter(r => !r.success).length;
+
+      results.installed += successes;
+      results.failed += failures;
+
+      if (failures === 0) {
+        spinner.succeed(`${skill.name} → ${successes} provider(s)`);
+      } else {
+        spinner.warn(`${skill.name} → ${successes} ok, ${failures} failed`);
+      }
+    } catch (err) {
+      spinner.fail(`${skill.name}: ${err.message}`);
+      results.failed++;
+    }
+  }
+
+  console.log('');
+  console.log(chalk.bold('Summary:'));
+  console.log(chalk.green(`  ✓ Installed: ${results.installed}`));
+  if (results.failed > 0) {
+    console.log(chalk.red(`  ✗ Failed: ${results.failed}`));
+  }
+  console.log('');
+}

package/src/commands/uninstall.js

@@ -0,0 +1,92 @@
+import chalk from 'chalk';
+import Enquirer from 'enquirer';
+const { prompt } = Enquirer;
+import ora from 'ora';
+import { listCentralSkills, uninstallSkillFromProvider, getSkillInstallStatus } from '../lib/skills.js';
+import { loadConfig } from '../lib/config.js';
+import { providers, getProviderIds } from '../providers/index.js';
+
+export async function uninstallCommand(skillName, options) {
+  console.log(chalk.bold('\n🗑️  Uninstall skill from providers\n'));
+
+  const config = await loadConfig();
+
+  // If no skill name, show interactive picker
+  if (!skillName) {
+    const skills = await listCentralSkills();
+    if (skills.length === 0) {
+      console.log(chalk.yellow('No skills found.'));
+      return;
+    }
+
+    const answer = await prompt({
+      type: 'select',
+      name: 'skill',
+      message: 'Select a skill to uninstall:',
+      choices: skills.map(s => ({
+        name: s.name,
+        message: `${s.name} - ${chalk.dim(s.description || 'No description')}`,
+        value: s.name
+      }))
+    });
+    skillName = answer.skill;
+  }
+
+  // Determine which providers to uninstall from
+  let targetProviders = options.providers
+    ? options.providers.split(',').map(p => p.trim())
+    : config.enabledProviders;
+
+  if (options.all) {
+    targetProviders = getProviderIds();
+  }
+
+  // Determine scope
+  const scope = options.project ? 'project' : 'global';
+
+  // Confirm if not using --yes flag
+  if (!options.yes) {
+    const providerNames = targetProviders.map(id => providers[id]?.name || id).join(', ');
+    const answer = await prompt({
+      type: 'confirm',
+      name: 'confirm',
+      message: `Uninstall '${skillName}' from ${providerNames}?`,
+      initial: false
+    });
+
+    if (!answer.confirm) {
+      console.log(chalk.yellow('Cancelled.'));
+      return;
+    }
+  }
+
+  console.log(chalk.dim(`Uninstalling '${skillName}' from ${scope} scope...\n`));
+
+  let removedCount = 0;
+
+  for (const providerId of targetProviders) {
+    const provider = providers[providerId];
+    if (!provider) continue;
+
+    try {
+      const result = await uninstallSkillFromProvider(skillName, providerId, scope);
+
+      if (result.removed) {
+        console.log(chalk.green(`  ✓ ${provider.name}`));
+        removedCount++;
+      } else {
+        console.log(chalk.dim(`  - ${provider.name} (not installed)`));
+      }
+    } catch (err) {
+      console.log(chalk.red(`  ✗ ${provider.name}: ${err.message}`));
+    }
+  }
+
+  console.log('');
+  if (removedCount > 0) {
+    console.log(chalk.green(`Removed from ${removedCount} provider(s)`));
+  } else {
+    console.log(chalk.yellow('Nothing to remove'));
+  }
+  console.log('');
+}

package/src/index.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { initConfig } from './lib/config.js';
+import { createCommand } from './commands/create.js';
+import { installCommand } from './commands/install.js';
+import { listCommand, listProvidersCommand } from './commands/list.js';
+import { syncCommand } from './commands/sync.js';
+import { uninstallCommand } from './commands/uninstall.js';
+import { configCommand, enableCommand, disableCommand } from './commands/config.js';
+import { openCommand, openRepoCommand } from './commands/open.js';
+
+const program = new Command();
+
+// Initialize config on startup
+await initConfig();
+
+program
+  .name('dotai')
+  .description('Dotfiles for AI - manage skills & MCP servers across all your AI coding assistants')
+  .version('1.0.0');
+
+// Skill subcommand
+const skill = program.command('skill').description('Manage AI agent skills');
+
+skill
+  .command('create [name]')
+  .description('Create a new skill (opens editor for instructions)')
+  .option('-d, --description <desc>', 'Short description of the skill')
+  .action(createCommand);
+
+skill
+  .command('install [skill]')
+  .description('Install a skill to providers')
+  .option('-p, --providers <list>', 'Comma-separated list of providers')
+  .option('-a, --all', 'Install to all providers')
+  .option('--project', 'Install to project scope (default: global)')
+  .option('-i, --interactive', 'Interactively select providers')
+  .action(installCommand);
+
+skill
+  .command('uninstall [skill]')
+  .description('Uninstall a skill from providers')
+  .option('-p, --providers <list>', 'Comma-separated list of providers')
+  .option('-a, --all', 'Uninstall from all providers')
+  .option('--project', 'Uninstall from project scope (default: global)')
+  .option('-y, --yes', 'Skip confirmation')
+  .action(uninstallCommand);
+
+skill
+  .command('list')
+  .alias('ls')
+  .description('List all skills in your repository')
+  .option('-v, --verbose', 'Show installation status')
+  .action(listCommand);
+
+skill
+  .command('sync')
+  .description('Sync all skills to enabled providers')
+  .option('-p, --providers <list>', 'Comma-separated list of providers')
+  .option('-a, --all', 'Sync to all providers')
+  .option('--project', 'Sync to project scope (default: global)')
+  .action(syncCommand);
+
+skill
+  .command('open [skill]')
+  .description('Open a skill folder or file')
+  .option('-f, --file', 'Open SKILL.md file directly')
+  .action(openCommand);
+
+// MCP subcommand (placeholder for now)
+const mcp = program.command('mcp').description('Manage MCP servers (coming soon)');
+
+mcp
+  .command('add')
+  .description('Add an MCP server (coming soon)')
+  .action(() => {
+    console.log(chalk.yellow('\nMCP management coming soon!\n'));
+    console.log(chalk.dim('This will let you configure MCP servers once and sync to:'));
+    console.log(chalk.dim('  • Claude Code    • Claude Desktop   • Cursor'));
+    console.log(chalk.dim('  • VS Code        • Cline            • Windsurf\n'));
+  });
+
+mcp
+  .command('list')
+  .description('List MCP servers (coming soon)')
+  .action(() => {
+    console.log(chalk.yellow('\nMCP management coming soon!\n'));
+  });
+
+// Config commands
+program
+  .command('providers')
+  .description('List all supported providers')
+  .action(listProvidersCommand);
+
+program
+  .command('config')
+  .description('Configure dotai settings')
+  .option('-s, --show', 'Show current configuration')
+  .action(configCommand);
+
+program
+  .command('enable <provider>')
+  .description('Enable a provider')
+  .action(enableCommand);
+
+program
+  .command('disable <provider>')
+  .description('Disable a provider')
+  .action(disableCommand);
+
+program
+  .command('repo')
+  .description('Open the dotai repository folder')
+  .action(openRepoCommand);
+
+// Show help if no command
+program.parse();
+
+if (!process.argv.slice(2).length) {
+  console.log(chalk.bold(`
+  ╔═══════════════════════════════════════════════════════════╗
+  ║                        dotai v1.0.0                       ║
+  ║         Dotfiles for AI - Skills & MCP in one place       ║
+  ╚═══════════════════════════════════════════════════════════╝
+  `));
+
+  console.log(chalk.bold('  Skills - manage across Claude, Gemini, Cursor, Codex & more:'));
+  console.log(`    ${chalk.cyan('dotai skill create')}         Create a new skill`);
+  console.log(`    ${chalk.cyan('dotai skill install <name>')} Install to all providers`);
+  console.log(`    ${chalk.cyan('dotai skill list')}           List your skills`);
+  console.log(`    ${chalk.cyan('dotai skill sync')}           Sync all skills\n`);
+
+  console.log(chalk.bold('  MCP Servers - coming soon:'));
+  console.log(`    ${chalk.dim('dotai mcp add')}              Add an MCP server`);
+  console.log(`    ${chalk.dim('dotai mcp sync')}             Sync to all apps\n`);
+
+  console.log(chalk.dim('  Run "dotai --help" for all commands\n'));
+}

package/src/lib/config.js

@@ -0,0 +1,90 @@
+import fs from 'fs-extra';
+import { getConfigDir, getConfigFilePath, getSkillsRepoDir } from './paths.js';
+import { getProviderIds } from '../providers/index.js';
+
+const defaultConfig = {
+  enabledProviders: getProviderIds(),
+  defaultScope: 'global', // 'global' or 'project'
+  skillsRepo: null, // Custom skills repo path (null = use default)
+  createdAt: new Date().toISOString()
+};
+
+/**
+ * Initialize config directory and files
+ */
+export async function initConfig() {
+  const configDir = getConfigDir();
+  const skillsRepoDir = getSkillsRepoDir();
+  const configFile = getConfigFilePath();
+
+  // Create directories
+  await fs.ensureDir(configDir);
+  await fs.ensureDir(skillsRepoDir);
+
+  // Create config file if it doesn't exist
+  if (!await fs.pathExists(configFile)) {
+    await fs.writeJson(configFile, defaultConfig, { spaces: 2 });
+  }
+
+  return loadConfig();
+}
+
+/**
+ * Load config from file
+ */
+export async function loadConfig() {
+  const configFile = getConfigFilePath();
+
+  if (!await fs.pathExists(configFile)) {
+    return { ...defaultConfig };
+  }
+
+  try {
+    const config = await fs.readJson(configFile);
+    return { ...defaultConfig, ...config };
+  } catch (err) {
+    console.error('Error loading config:', err.message);
+    return { ...defaultConfig };
+  }
+}
+
+/**
+ * Save config to file
+ */
+export async function saveConfig(config) {
+  const configFile = getConfigFilePath();
+  await fs.ensureDir(getConfigDir());
+  await fs.writeJson(configFile, config, { spaces: 2 });
+}
+
+/**
+ * Update specific config values
+ */
+export async function updateConfig(updates) {
+  const config = await loadConfig();
+  const newConfig = { ...config, ...updates, updatedAt: new Date().toISOString() };
+  await saveConfig(newConfig);
+  return newConfig;
+}
+
+/**
+ * Enable a provider
+ */
+export async function enableProvider(providerId) {
+  const config = await loadConfig();
+  if (!config.enabledProviders.includes(providerId)) {
+    config.enabledProviders.push(providerId);
+    await saveConfig(config);
+  }
+  return config;
+}
+
+/**
+ * Disable a provider
+ */
+export async function disableProvider(providerId) {
+  const config = await loadConfig();
+  config.enabledProviders = config.enabledProviders.filter(id => id !== providerId);
+  await saveConfig(config);
+  return config;
+}

package/src/lib/paths.js

@@ -0,0 +1,60 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { platform } from 'process';
+
+/**
+ * Get the user's home directory (cross-platform)
+ */
+export function getHomeDir() {
+  return homedir();
+}
+
+/**
+ * Get the dotai config directory
+ * Mac/Linux: ~/.dotai
+ * Windows: %USERPROFILE%\.dotai
+ */
+export function getConfigDir() {
+  return join(getHomeDir(), '.dotai');
+}
+
+/**
+ * Get the central skills repository directory
+ */
+export function getSkillsRepoDir() {
+  return join(getConfigDir(), 'skills');
+}
+
+/**
+ * Get the config file path
+ */
+export function getConfigFilePath() {
+  return join(getConfigDir(), 'config.json');
+}
+
+/**
+ * Check if running on Windows
+ */
+export function isWindows() {
+  return platform === 'win32';
+}
+
+/**
+ * Normalize path for the current OS
+ */
+export function normalizePath(p) {
+  if (isWindows()) {
+    return p.replace(/\//g, '\\');
+  }
+  return p;
+}
+
+/**
+ * Expand ~ to home directory
+ */
+export function expandHome(p) {
+  if (p.startsWith('~')) {
+    return join(getHomeDir(), p.slice(1));
+  }
+  return p;
+}