dotai-cli 1.0.0

package/README.md

@@ -0,0 +1,186 @@
+# dotai
+
+**Dotfiles for AI** - Manage skills and MCP servers across all your AI coding assistants from one place.
+
+```bash
+npm install -g dotai-cli
+```
+
+## Why dotai?
+
+You use multiple AI coding assistants - Claude Code, Cursor, Gemini CLI, Codex, etc. Each has its own config location for skills and MCP servers. **dotai** lets you configure once and sync everywhere.
+
+## Features
+
+- **Skills Management** - Create, install, and sync skills across providers
+- **MCP Servers** - Configure once, deploy to all apps *(coming soon)*
+- **AI-Assisted Creation** - Generate skills with LLM prompts
+- **Cross-Platform** - Works on Mac, Windows, and Linux
+
+## Quick Start
+
+```bash
+# Create a skill (opens editor for full instructions)
+dotai skill create
+
+# Install to all your AI assistants
+dotai skill install my-skill
+
+# List your skills
+dotai skill list
+
+# Sync everything
+dotai skill sync
+```
+
+## Supported Providers
+
+### Skills
+| Provider | Global Path | Project Path |
+|----------|-------------|--------------|
+| Claude Code | `~/.claude/skills/<name>/` | `.claude/skills/<name>/` |
+| Cursor | `~/.cursor/skills/<name>/` | `.cursor/skills/<name>/` |
+| Gemini CLI | `~/.gemini/skills/<name>/` | `.gemini/skills/<name>/` |
+| OpenCode | `~/.config/opencode/skill/<name>/` | `.opencode/skill/<name>/` |
+| Codex CLI | `~/.codex/skills/<name>/` | `skills/<name>/` |
+| Antigravity | `~/.gemini/antigravity/skills/<name>/` | `.agent/skills/<name>/` |
+
+### MCP Servers *(coming soon)*
+| App | Global Config | Project Config |
+|-----|---------------|----------------|
+| Claude Code | `~/.claude.json` | `.mcp.json` |
+| Claude Desktop | `~/Library/Application Support/Claude/claude_desktop_config.json` | - |
+| Cursor | `~/.cursor/mcp.json` | `.cursor/mcp.json` |
+| Windsurf | `~/.codeium/windsurf/mcp_config.json` | - |
+| VS Code | User `settings.json` | `.vscode/mcp.json` |
+| Cline | VS Code storage `cline_mcp_settings.json` | - |
+| Zed | `~/.config/zed/settings.json` (key: `context_servers`) | - |
+| Roo Code | VS Code storage `mcp_settings.json` | `.roo/mcp.json` |
+| Antigravity | `mcp_config.json` (via MCP Store) | - |
+
+## Commands
+
+### Skills
+
+```bash
+# Create a new skill
+dotai skill create [name]
+dotai skill create my-skill -d "Short description"
+
+# Install skill to providers
+dotai skill install <name>              # Install to enabled providers
+dotai skill install <name> -a           # Install to ALL providers
+dotai skill install <name> -p claude-code,cursor  # Specific providers
+dotai skill install <name> --project    # Project scope instead of global
+dotai skill install /path/to/skill      # Import from external path
+
+# List skills
+dotai skill list                        # List all skills
+dotai skill list -v                     # With installation status
+
+# Sync all skills
+dotai skill sync                        # Sync to enabled providers
+dotai skill sync -a                     # Sync to all providers
+
+# Uninstall
+dotai skill uninstall <name>
+dotai skill uninstall <name> -y         # Skip confirmation
+
+# Open in editor/finder
+dotai skill open <name>                 # Open folder
+dotai skill open <name> -f              # Open SKILL.md file
+```
+
+### MCP Servers *(coming soon)*
+
+```bash
+dotai mcp add                           # Add an MCP server
+dotai mcp list                          # List configured servers
+dotai mcp sync                          # Sync to all apps
+dotai mcp remove <name>                 # Remove a server
+```
+
+### Configuration
+
+```bash
+dotai providers                         # List supported providers
+dotai config                            # Interactive configuration
+dotai config -s                         # Show current config
+dotai enable <provider>                 # Enable a provider
+dotai disable <provider>                # Disable a provider
+dotai repo                              # Open dotai folder
+```
+
+## Creating Skills with AI
+
+When you run `dotai skill create`, it:
+
+1. Asks for skill name and description
+2. Creates the skill folder with a template
+3. Opens SKILL.md in your editor
+
+**Pro tip:** Describe what you want the skill to do to any LLM (ChatGPT, Claude, etc.) and ask it to generate the SKILL.md content. Then paste it into the file.
+
+Example prompt:
+```
+Create a SKILL.md file for an AI coding assistant skill that helps with
+database migrations. It should include best practices for writing migrations,
+rollback strategies, and common pitfalls to avoid. Use YAML frontmatter with
+name and description fields.
+```
+
+## Skill Structure
+
+```
+my-skill/
+├── SKILL.md           # Required: Instructions for the AI
+├── scripts/           # Optional: Helper scripts
+├── references/        # Optional: Documentation
+└── templates/         # Optional: Code templates
+```
+
+### SKILL.md Format
+
+```markdown
+---
+name: my-skill
+description: Short description for auto-discovery (max 200 chars)
+---
+
+# My Skill
+
+Detailed instructions for the AI agent.
+
+## When to use this skill
+
+- Scenario 1
+- Scenario 2
+
+## Instructions
+
+Step-by-step guidance...
+
+## Examples
+
+Show expected inputs/outputs...
+```
+
+## Data Location
+
+All your configurations are stored in `~/.dotai/`:
+
+```
+~/.dotai/
+├── config.json        # Your settings
+└── skills/            # Central skill repository
+    ├── my-skill/
+    └── another-skill/
+```
+
+## License
+
+MIT
+
+---
+
+Built by [Jithin Garapati](https://github.com/jithin-garapati)

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "dotai-cli",
+  "version": "1.0.0",
+  "description": "Unified CLI for AI coding assistants - manage skills and MCP servers across Claude Code, Gemini CLI, Cursor, VS Code, and more",
+  "main": "src/index.js",
+  "type": "module",
+  "bin": {
+    "dotai": "./src/index.js"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "link": "npm link"
+  },
+  "keywords": [
+    "ai",
+    "dotfiles",
+    "skills",
+    "mcp",
+    "claude",
+    "claude-code",
+    "gemini",
+    "cursor",
+    "cline",
+    "opencode",
+    "codex",
+    "cli",
+    "agent",
+    "mcp-server",
+    "config"
+  ],
+  "author": "Jithin Garapati",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jithin-garapati/dotai"
+  },
+  "homepage": "https://github.com/jithin-garapati/dotai#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "src/**/*",
+    "README.md"
+  ],
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "enquirer": "^2.4.1",
+    "fs-extra": "^11.2.0",
+    "gray-matter": "^4.0.3",
+    "ora": "^8.0.1",
+    "yaml": "^2.4.1"
+  }
+}

package/src/commands/config.js

@@ -0,0 +1,93 @@
+import chalk from 'chalk';
+import Enquirer from 'enquirer';
+const { prompt } = Enquirer;
+import { loadConfig, saveConfig, enableProvider, disableProvider } from '../lib/config.js';
+import { providers, getProviderIds } from '../providers/index.js';
+import { getConfigFilePath, getSkillsRepoDir } from '../lib/paths.js';
+
+export async function configCommand(options) {
+  const config = await loadConfig();
+
+  if (options.show) {
+    console.log(chalk.bold('\n⚙️  Current Configuration\n'));
+    console.log(chalk.dim(`Config file: ${getConfigFilePath()}`));
+    console.log(chalk.dim(`Skills repo: ${getSkillsRepoDir()}\n`));
+    console.log(JSON.stringify(config, null, 2));
+    console.log('');
+    return;
+  }
+
+  // Interactive config
+  console.log(chalk.bold('\n⚙️  Configure skills-cli\n'));
+
+  const allProviders = getProviderIds();
+
+  const answers = await prompt([
+    {
+      type: 'multiselect',
+      name: 'enabledProviders',
+      message: 'Select providers to enable:',
+      choices: allProviders.map(id => ({
+        name: id,
+        message: `${providers[id].name} - ${chalk.dim(providers[id].description)}`,
+        value: id
+      })),
+      initial: config.enabledProviders
+    },
+    {
+      type: 'select',
+      name: 'defaultScope',
+      message: 'Default installation scope:',
+      choices: [
+        { name: 'global', message: 'Global - Available in all projects' },
+        { name: 'project', message: 'Project - Only in current project' }
+      ],
+      initial: config.defaultScope === 'project' ? 1 : 0
+    }
+  ]);
+
+  const newConfig = {
+    ...config,
+    enabledProviders: answers.enabledProviders,
+    defaultScope: answers.defaultScope,
+    updatedAt: new Date().toISOString()
+  };
+
+  await saveConfig(newConfig);
+
+  console.log(chalk.green('\n✓ Configuration saved\n'));
+}
+
+export async function enableCommand(providerId) {
+  if (!providerId) {
+    console.error(chalk.red('Error: Provider ID required'));
+    console.log(`Available providers: ${getProviderIds().join(', ')}`);
+    return;
+  }
+
+  if (!providers[providerId]) {
+    console.error(chalk.red(`Unknown provider: ${providerId}`));
+    console.log(`Available providers: ${getProviderIds().join(', ')}`);
+    return;
+  }
+
+  await enableProvider(providerId);
+  console.log(chalk.green(`✓ Enabled ${providers[providerId].name}`));
+}
+
+export async function disableCommand(providerId) {
+  if (!providerId) {
+    console.error(chalk.red('Error: Provider ID required'));
+    console.log(`Available providers: ${getProviderIds().join(', ')}`);
+    return;
+  }
+
+  if (!providers[providerId]) {
+    console.error(chalk.red(`Unknown provider: ${providerId}`));
+    console.log(`Available providers: ${getProviderIds().join(', ')}`);
+    return;
+  }
+
+  await disableProvider(providerId);
+  console.log(chalk.green(`✓ Disabled ${providers[providerId].name}`));
+}

package/src/commands/create.js

@@ -0,0 +1,120 @@
+import chalk from 'chalk';
+import Enquirer from 'enquirer';
+const { prompt } = Enquirer;
+import ora from 'ora';
+import { spawn } from 'child_process';
+import { platform } from 'os';
+import { createSkill } from '../lib/skills.js';
+
+/**
+ * Get the command to open a file in default editor
+ */
+function getEditorCommand() {
+  // Check for $EDITOR environment variable first
+  if (process.env.EDITOR) {
+    return process.env.EDITOR;
+  }
+
+  // Fall back to platform defaults
+  switch (platform()) {
+    case 'darwin':
+      return 'open -t'; // Opens in default text editor on Mac
+    case 'win32':
+      return 'notepad';
+    default:
+      return process.env.VISUAL || 'xdg-open';
+  }
+}
+
+/**
+ * Open file in editor
+ */
+function openInEditor(filePath) {
+  const editor = getEditorCommand();
+  const parts = editor.split(' ');
+  const cmd = parts[0];
+  const args = [...parts.slice(1), filePath];
+
+  return spawn(cmd, args, {
+    detached: true,
+    stdio: 'ignore'
+  }).unref();
+}
+
+export async function createCommand(name, options) {
+  console.log(chalk.bold('\n🔧 Create a new skill\n'));
+
+  let skillName = name;
+  let description = options.description;
+
+  // Interactive mode if name not provided
+  if (!skillName) {
+    const answers = await prompt([
+      {
+        type: 'input',
+        name: 'name',
+        message: 'Skill name (lowercase, hyphens allowed):',
+        validate: (value) => {
+          if (!value) return 'Name is required';
+          if (!/^[a-z0-9-]+$/.test(value)) {
+            return 'Name must be lowercase with hyphens only';
+          }
+          return true;
+        }
+      },
+      {
+        type: 'input',
+        name: 'description',
+        message: 'Short description for auto-discovery (max 200 chars):',
+        validate: (value) => {
+          if (!value) return 'Description is required';
+          if (value.length > 200) return 'Description must be 200 characters or less';
+          return true;
+        }
+      }
+    ]);
+
+    skillName = answers.name;
+    description = answers.description;
+  }
+
+  // Validate inputs
+  if (!skillName) {
+    console.error(chalk.red('Error: Skill name is required'));
+    process.exit(1);
+  }
+
+  if (!description) {
+    console.error(chalk.red('Error: Description is required (use -d or --description)'));
+    process.exit(1);
+  }
+
+  const spinner = ora('Creating skill...').start();
+
+  try {
+    const result = await createSkill(skillName, description);
+    spinner.succeed(chalk.green(`Skill '${skillName}' created!`));
+
+    console.log(chalk.dim(`\nLocation: ${result.path}`));
+
+    // Ask if user wants to open in editor
+    const { openEditor } = await prompt({
+      type: 'confirm',
+      name: 'openEditor',
+      message: 'Open SKILL.md in editor to write instructions?',
+      initial: true
+    });
+
+    if (openEditor) {
+      console.log(chalk.dim(`\nOpening ${result.skillMdPath}...\n`));
+      openInEditor(result.skillMdPath);
+    }
+
+    console.log(chalk.yellow('\nWhen ready, install with:'));
+    console.log(`  ${chalk.cyan(`dotai skill install ${skillName}`)}\n`);
+
+  } catch (err) {
+    spinner.fail(chalk.red(`Failed to create skill: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/install.js

@@ -0,0 +1,120 @@
+import chalk from 'chalk';
+import Enquirer from 'enquirer';
+const { prompt } = Enquirer;
+import ora from 'ora';
+import fs from 'fs-extra';
+import { installSkill, listCentralSkills, importSkill } from '../lib/skills.js';
+import { loadConfig } from '../lib/config.js';
+import { providers, getProviderIds } from '../providers/index.js';
+
+export async function installCommand(skillNameOrPath, options) {
+  console.log(chalk.bold('\n📦 Install skill to providers\n'));
+
+  const config = await loadConfig();
+  let skillName = skillNameOrPath;
+
+  // Check if it's a path to a skill folder
+  if (skillNameOrPath && await fs.pathExists(skillNameOrPath)) {
+    const spinner = ora('Importing skill from path...').start();
+    try {
+      const imported = await importSkill(skillNameOrPath);
+      spinner.succeed(`Imported skill '${imported.name}'`);
+      skillName = imported.name;
+    } catch (err) {
+      spinner.fail(chalk.red(`Failed to import: ${err.message}`));
+      process.exit(1);
+    }
+  }
+
+  // If no skill name, show interactive picker
+  if (!skillName) {
+    const skills = await listCentralSkills();
+    if (skills.length === 0) {
+      console.log(chalk.yellow('No skills found in your repository.'));
+      console.log(`Create one with: ${chalk.cyan('dotai skill create')}\n`);
+      process.exit(0);
+    }
+
+    const answer = await prompt({
+      type: 'select',
+      name: 'skill',
+      message: 'Select a skill to install:',
+      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 install to
+  let targetProviders = options.providers
+    ? options.providers.split(',').map(p => p.trim())
+    : config.enabledProviders;
+
+  // If --all flag, use all providers
+  if (options.all) {
+    targetProviders = getProviderIds();
+  }
+
+  // Interactive provider selection if requested
+  if (options.interactive) {
+    const answer = await prompt({
+      type: 'multiselect',
+      name: 'providers',
+      message: 'Select providers to install to:',
+      choices: Object.values(providers).map(p => ({
+        name: p.id,
+        message: `${p.name} - ${chalk.dim(p.description)}`,
+        value: p.id
+      })),
+      initial: targetProviders
+    });
+    targetProviders = answer.providers;
+  }
+
+  // Determine scope
+  const scope = options.project ? 'project' : 'global';
+
+  console.log(chalk.dim(`Installing '${skillName}' to ${scope} scope...\n`));
+
+  const spinner = ora('Installing...').start();
+
+  try {
+    const results = await installSkill(skillName, targetProviders, scope);
+
+    spinner.stop();
+
+    // Show results
+    let successCount = 0;
+    let failCount = 0;
+
+    for (const result of results) {
+      const provider = providers[result.providerId];
+      if (result.success) {
+        successCount++;
+        console.log(chalk.green(`  ✓ ${provider.name}`));
+        console.log(chalk.dim(`    ${result.targetPath}`));
+      } else {
+        failCount++;
+        console.log(chalk.red(`  ✗ ${provider.name}: ${result.error}`));
+      }
+    }
+
+    console.log('');
+
+    if (successCount > 0) {
+      console.log(chalk.green(`Installed to ${successCount} provider(s)`));
+    }
+    if (failCount > 0) {
+      console.log(chalk.red(`Failed for ${failCount} provider(s)`));
+    }
+
+    console.log('');
+
+  } catch (err) {
+    spinner.fail(chalk.red(`Failed to install: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/list.js

@@ -0,0 +1,68 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import { listCentralSkills, getSkillInstallStatus } from '../lib/skills.js';
+import { getSkillsRepoDir } from '../lib/paths.js';
+import { providers } from '../providers/index.js';
+
+export async function listCommand(options) {
+  console.log(chalk.bold('\n📋 Skills Repository\n'));
+
+  const skills = await listCentralSkills();
+
+  if (skills.length === 0) {
+    console.log(chalk.yellow('No skills found in your repository.'));
+    console.log(chalk.dim(`Location: ${getSkillsRepoDir()}`));
+    console.log(`\nCreate one with: ${chalk.cyan('dotai skill create')}\n`);
+    return;
+  }
+
+  // Show skills with installation status
+  for (const skill of skills) {
+    console.log(chalk.bold.white(skill.name));
+    console.log(chalk.dim(`  ${skill.description || 'No description'}`));
+
+    if (options.verbose) {
+      console.log(chalk.dim(`  Path: ${skill.path}`));
+
+      // Show installation status
+      const status = await getSkillInstallStatus(skill.name);
+      const installed = [];
+
+      for (const [providerId, providerStatus] of Object.entries(status)) {
+        if (providerStatus.global || providerStatus.project) {
+          const scopes = [];
+          if (providerStatus.global) scopes.push('global');
+          if (providerStatus.project) scopes.push('project');
+          installed.push(`${providerStatus.name} (${scopes.join(', ')})`);
+        }
+      }
+
+      if (installed.length > 0) {
+        console.log(chalk.green(`  Installed: ${installed.join(', ')}`));
+      } else {
+        console.log(chalk.yellow('  Not installed anywhere'));
+      }
+    }
+
+    console.log('');
+  }
+
+  console.log(chalk.dim(`Total: ${skills.length} skill(s)`));
+  console.log(chalk.dim(`Location: ${getSkillsRepoDir()}\n`));
+
+  if (!options.verbose) {
+    console.log(chalk.dim(`Use ${chalk.cyan('dotai skill list -v')} to see installation status\n`));
+  }
+}
+
+export async function listProvidersCommand() {
+  console.log(chalk.bold('\n🔌 Supported Providers\n'));
+
+  for (const provider of Object.values(providers)) {
+    console.log(chalk.bold.white(provider.name) + chalk.dim(` (${provider.id})`));
+    console.log(chalk.dim(`  ${provider.description}`));
+    console.log(chalk.dim(`  Global: ${provider.globalPath()}`));
+    console.log(chalk.dim(`  Project: ${provider.projectPath}/`));
+    console.log('');
+  }
+}