dotai-cli 1.0.0

package/src/lib/skills.js

@@ -0,0 +1,261 @@
+import fs from 'fs-extra';
+import { join, basename, dirname } from 'path';
+import matter from 'gray-matter';
+import { getSkillsRepoDir } from './paths.js';
+import { providers, getGlobalSkillPath, getProjectSkillPath } from '../providers/index.js';
+
+/**
+ * Skill template with frontmatter
+ */
+export function createSkillTemplate(name, description, instructions = '') {
+  return `---
+name: ${name}
+description: ${description}
+---
+
+# ${name}
+
+${instructions || `Instructions for the ${name} skill.
+
+## When to use this skill
+
+- Use this when...
+- This is helpful for...
+
+## How to use it
+
+Step-by-step guidance, conventions, and patterns the agent should follow.
+
+## Examples
+
+Include examples to help the agent understand expected behavior.
+`}
+`;
+}
+
+/**
+ * Parse a SKILL.md file
+ */
+export async function parseSkillFile(filePath) {
+  try {
+    const content = await fs.readFile(filePath, 'utf-8');
+    const { data, content: body } = matter(content);
+    return {
+      name: data.name || basename(dirname(filePath)),
+      description: data.description || '',
+      metadata: data,
+      body,
+      filePath
+    };
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * List all skills in the central repository
+ */
+export async function listCentralSkills() {
+  const skillsDir = getSkillsRepoDir();
+
+  if (!await fs.pathExists(skillsDir)) {
+    return [];
+  }
+
+  const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+  const skills = [];
+
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const skillMdPath = join(skillsDir, entry.name, 'SKILL.md');
+      if (await fs.pathExists(skillMdPath)) {
+        const skill = await parseSkillFile(skillMdPath);
+        if (skill) {
+          skills.push({
+            ...skill,
+            folder: entry.name,
+            path: join(skillsDir, entry.name)
+          });
+        }
+      }
+    }
+  }
+
+  return skills;
+}
+
+/**
+ * Get a skill from central repo by name
+ */
+export async function getCentralSkill(name) {
+  const skillsDir = getSkillsRepoDir();
+  const skillPath = join(skillsDir, name);
+  const skillMdPath = join(skillPath, 'SKILL.md');
+
+  if (!await fs.pathExists(skillMdPath)) {
+    return null;
+  }
+
+  const skill = await parseSkillFile(skillMdPath);
+  if (skill) {
+    skill.folder = name;
+    skill.path = skillPath;
+  }
+
+  return skill;
+}
+
+/**
+ * Create a new skill in the central repository
+ */
+export async function createSkill(name, description, instructions = '') {
+  const skillsDir = getSkillsRepoDir();
+  const skillPath = join(skillsDir, name);
+  const skillMdPath = join(skillPath, 'SKILL.md');
+
+  // Check if skill already exists
+  if (await fs.pathExists(skillPath)) {
+    throw new Error(`Skill '${name}' already exists`);
+  }
+
+  // Create skill directory
+  await fs.ensureDir(skillPath);
+
+  // Create SKILL.md
+  const content = createSkillTemplate(name, description, instructions);
+  await fs.writeFile(skillMdPath, content, 'utf-8');
+
+  return {
+    name,
+    description,
+    path: skillPath,
+    skillMdPath
+  };
+}
+
+/**
+ * Install a skill to a specific provider
+ */
+export async function installSkillToProvider(skillName, providerId, scope = 'global', projectRoot = process.cwd()) {
+  const provider = providers[providerId];
+  if (!provider) {
+    throw new Error(`Unknown provider: ${providerId}`);
+  }
+
+  // Get source skill
+  const skill = await getCentralSkill(skillName);
+  if (!skill) {
+    throw new Error(`Skill '${skillName}' not found in central repository`);
+  }
+
+  // Determine target path
+  const targetPath = scope === 'global'
+    ? getGlobalSkillPath(providerId, skillName)
+    : getProjectSkillPath(providerId, skillName, projectRoot);
+
+  // Copy skill folder
+  await fs.ensureDir(targetPath);
+  await fs.copy(skill.path, targetPath, { overwrite: true });
+
+  return {
+    skillName,
+    providerId,
+    scope,
+    targetPath
+  };
+}
+
+/**
+ * Install a skill to multiple providers
+ */
+export async function installSkill(skillName, providerIds, scope = 'global', projectRoot = process.cwd()) {
+  const results = [];
+
+  for (const providerId of providerIds) {
+    try {
+      const result = await installSkillToProvider(skillName, providerId, scope, projectRoot);
+      results.push({ ...result, success: true });
+    } catch (err) {
+      results.push({
+        skillName,
+        providerId,
+        scope,
+        success: false,
+        error: err.message
+      });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Uninstall a skill from a provider
+ */
+export async function uninstallSkillFromProvider(skillName, providerId, scope = 'global', projectRoot = process.cwd()) {
+  const provider = providers[providerId];
+  if (!provider) {
+    throw new Error(`Unknown provider: ${providerId}`);
+  }
+
+  const targetPath = scope === 'global'
+    ? getGlobalSkillPath(providerId, skillName)
+    : getProjectSkillPath(providerId, skillName, projectRoot);
+
+  if (await fs.pathExists(targetPath)) {
+    await fs.remove(targetPath);
+    return { removed: true, path: targetPath };
+  }
+
+  return { removed: false, path: targetPath };
+}
+
+/**
+ * Check where a skill is installed
+ */
+export async function getSkillInstallStatus(skillName) {
+  const status = {};
+
+  for (const [providerId, provider] of Object.entries(providers)) {
+    const globalPath = getGlobalSkillPath(providerId, skillName);
+    const projectPath = getProjectSkillPath(providerId, skillName);
+
+    status[providerId] = {
+      name: provider.name,
+      global: await fs.pathExists(globalPath),
+      globalPath,
+      project: await fs.pathExists(projectPath),
+      projectPath
+    };
+  }
+
+  return status;
+}
+
+/**
+ * Import a skill from an external path to central repo
+ */
+export async function importSkill(sourcePath) {
+  const skillMdPath = join(sourcePath, 'SKILL.md');
+
+  if (!await fs.pathExists(skillMdPath)) {
+    throw new Error(`No SKILL.md found in ${sourcePath}`);
+  }
+
+  const skill = await parseSkillFile(skillMdPath);
+  if (!skill) {
+    throw new Error(`Failed to parse SKILL.md in ${sourcePath}`);
+  }
+
+  const skillName = skill.name || basename(sourcePath);
+  const targetPath = join(getSkillsRepoDir(), skillName);
+
+  // Copy to central repo
+  await fs.copy(sourcePath, targetPath, { overwrite: true });
+
+  return {
+    name: skillName,
+    path: targetPath,
+    imported: true
+  };
+}

package/src/providers/index.js

@@ -0,0 +1,125 @@
+import { join } from 'path';
+import { getHomeDir } from '../lib/paths.js';
+
+/**
+ * Provider definitions with their skill paths
+ * Each provider has:
+ * - name: Display name
+ * - id: Unique identifier
+ * - globalPath: Where global skills are stored
+ * - projectPath: Where project skills are stored (relative to project root)
+ * - skillFile: The instruction file name (usually SKILL.md)
+ * - enabled: Whether this provider is enabled by default
+ * - notes: Any special handling notes
+ */
+export const providers = {
+  'claude-code': {
+    name: 'Claude Code',
+    id: 'claude-code',
+    globalPath: () => join(getHomeDir(), '.claude', 'skills'),
+    projectPath: '.claude/skills',
+    skillFile: 'SKILL.md',
+    enabled: true,
+    description: 'Anthropic Claude Code CLI',
+    website: 'https://claude.ai/code'
+  },
+
+  'cursor': {
+    name: 'Cursor',
+    id: 'cursor',
+    globalPath: () => join(getHomeDir(), '.cursor', 'skills'),
+    projectPath: '.cursor/skills',
+    skillFile: 'SKILL.md',
+    enabled: true,
+    description: 'Cursor AI IDE',
+    website: 'https://cursor.com'
+  },
+
+  'gemini-cli': {
+    name: 'Gemini CLI',
+    id: 'gemini-cli',
+    globalPath: () => join(getHomeDir(), '.gemini', 'skills'),
+    projectPath: '.gemini/skills',
+    skillFile: 'SKILL.md',
+    enabled: true,
+    description: 'Google Gemini CLI',
+    website: 'https://geminicli.com'
+  },
+
+  'opencode': {
+    name: 'OpenCode',
+    id: 'opencode',
+    globalPath: () => join(getHomeDir(), '.config', 'opencode', 'skill'),
+    projectPath: '.opencode/skill',
+    skillFile: 'SKILL.md',
+    enabled: true,
+    description: 'OpenCode AI coding agent',
+    website: 'https://opencode.ai'
+  },
+
+  'codex-cli': {
+    name: 'Codex CLI',
+    id: 'codex-cli',
+    globalPath: () => join(getHomeDir(), '.codex', 'skills'),
+    projectPath: 'skills',
+    skillFile: 'SKILL.md',
+    enabled: true,
+    description: 'OpenAI Codex CLI',
+    website: 'https://openai.com/codex',
+    // Codex also uses AGENTS.md for global instructions
+    supportsAgentsMd: true,
+    agentsMdGlobalPath: () => join(getHomeDir(), '.codex', 'AGENTS.md'),
+    agentsMdProjectPath: 'AGENTS.md'
+  },
+
+  'antigravity': {
+    name: 'Antigravity',
+    id: 'antigravity',
+    globalPath: () => join(getHomeDir(), '.gemini', 'antigravity', 'skills'),
+    projectPath: '.agent/skills',
+    skillFile: 'SKILL.md',
+    enabled: true,
+    description: 'Antigravity agentic system',
+    website: 'https://github.com/vuralserhat86/antigravity-agentic-skills'
+  }
+};
+
+/**
+ * Get all provider IDs
+ */
+export function getProviderIds() {
+  return Object.keys(providers);
+}
+
+/**
+ * Get provider by ID
+ */
+export function getProvider(id) {
+  return providers[id];
+}
+
+/**
+ * Get all enabled providers
+ */
+export function getEnabledProviders(config = {}) {
+  const enabledProviders = config.enabledProviders || getProviderIds();
+  return enabledProviders.map(id => providers[id]).filter(Boolean);
+}
+
+/**
+ * Get global skill path for a provider and skill name
+ */
+export function getGlobalSkillPath(providerId, skillName) {
+  const provider = providers[providerId];
+  if (!provider) return null;
+  return join(provider.globalPath(), skillName);
+}
+
+/**
+ * Get project skill path for a provider and skill name
+ */
+export function getProjectSkillPath(providerId, skillName, projectRoot = process.cwd()) {
+  const provider = providers[providerId];
+  if (!provider) return null;
+  return join(projectRoot, provider.projectPath, skillName);
+}

package/src/providers/mcp.js

@@ -0,0 +1,184 @@
+import { join } from 'path';
+import { homedir, platform } from 'os';
+
+/**
+ * MCP Server provider definitions
+ * Each provider has different config file locations and formats
+ */
+export const mcpProviders = {
+  'claude-code': {
+    name: 'Claude Code',
+    id: 'claude-code',
+    globalPath: () => join(homedir(), '.claude.json'),
+    projectPath: '.mcp.json',
+    configKey: 'mcpServers',
+    format: 'json',
+    enabled: true,
+    description: 'Anthropic Claude Code CLI'
+  },
+
+  'claude-desktop': {
+    name: 'Claude Desktop',
+    id: 'claude-desktop',
+    globalPath: () => {
+      if (platform() === 'win32') {
+        return join(process.env.APPDATA || '', 'Claude', 'claude_desktop_config.json');
+      }
+      return join(homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    },
+    projectPath: null, // No project-level config
+    configKey: 'mcpServers',
+    format: 'json',
+    enabled: true,
+    description: 'Claude Desktop App'
+  },
+
+  'cursor': {
+    name: 'Cursor',
+    id: 'cursor',
+    globalPath: () => join(homedir(), '.cursor', 'mcp.json'),
+    projectPath: '.cursor/mcp.json',
+    configKey: 'mcpServers',
+    format: 'json',
+    enabled: true,
+    description: 'Cursor AI IDE'
+  },
+
+  'windsurf': {
+    name: 'Windsurf',
+    id: 'windsurf',
+    globalPath: () => join(homedir(), '.codeium', 'windsurf', 'mcp_config.json'),
+    projectPath: null,
+    configKey: 'mcpServers',
+    format: 'json',
+    enabled: true,
+    description: 'Windsurf IDE by Codeium'
+  },
+
+  'vscode': {
+    name: 'VS Code',
+    id: 'vscode',
+    globalPath: () => {
+      // VS Code stores in different locations per OS
+      if (platform() === 'win32') {
+        return join(process.env.APPDATA || '', 'Code', 'User', 'settings.json');
+      } else if (platform() === 'darwin') {
+        return join(homedir(), 'Library', 'Application Support', 'Code', 'User', 'settings.json');
+      }
+      return join(homedir(), '.config', 'Code', 'User', 'settings.json');
+    },
+    projectPath: '.vscode/mcp.json',
+    configKey: 'mcpServers', // For project config; global uses mcp.servers in settings
+    globalConfigKey: 'mcp.servers', // Different key for global settings.json
+    format: 'json',
+    enabled: true,
+    description: 'Visual Studio Code with GitHub Copilot'
+  },
+
+  'cline': {
+    name: 'Cline',
+    id: 'cline',
+    globalPath: () => {
+      // Cline stores in VS Code extension storage
+      if (platform() === 'win32') {
+        return join(process.env.APPDATA || '', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json');
+      } else if (platform() === 'darwin') {
+        return join(homedir(), 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json');
+      }
+      return join(homedir(), '.config', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json');
+    },
+    projectPath: null,
+    configKey: 'mcpServers',
+    format: 'json',
+    enabled: true,
+    description: 'Cline VS Code Extension'
+  },
+
+  'zed': {
+    name: 'Zed',
+    id: 'zed',
+    globalPath: () => {
+      if (platform() === 'darwin') {
+        return join(homedir(), '.config', 'zed', 'settings.json');
+      }
+      return join(homedir(), '.config', 'zed', 'settings.json');
+    },
+    projectPath: null,
+    configKey: 'context_servers', // Zed uses different key!
+    format: 'json',
+    enabled: true,
+    description: 'Zed Editor'
+  },
+
+  'roo-code': {
+    name: 'Roo Code',
+    id: 'roo-code',
+    globalPath: () => {
+      if (platform() === 'win32') {
+        return join(process.env.APPDATA || '', 'Code', 'User', 'globalStorage', 'rooveterinaryinc.roo-cline', 'settings', 'mcp_settings.json');
+      } else if (platform() === 'darwin') {
+        return join(homedir(), 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'rooveterinaryinc.roo-cline', 'settings', 'mcp_settings.json');
+      }
+      return join(homedir(), '.config', 'Code', 'User', 'globalStorage', 'rooveterinaryinc.roo-cline', 'settings', 'mcp_settings.json');
+    },
+    projectPath: '.roo/mcp.json',
+    configKey: 'mcpServers',
+    format: 'json',
+    enabled: true,
+    description: 'Roo Code VS Code Extension'
+  },
+
+  'antigravity': {
+    name: 'Antigravity',
+    id: 'antigravity',
+    globalPath: () => {
+      // Antigravity stores MCP config in its own location
+      // Access via MCP Store > Manage MCP Servers > View raw config
+      if (platform() === 'darwin') {
+        return join(homedir(), '.antigravity', 'mcp_config.json');
+      }
+      return join(homedir(), '.antigravity', 'mcp_config.json');
+    },
+    projectPath: null,
+    configKey: 'mcpServers',
+    format: 'json',
+    enabled: true,
+    description: 'Antigravity Editor',
+    note: 'Config accessible via MCP Store > Manage MCP Servers > View raw config'
+  }
+};
+
+/**
+ * Get all MCP provider IDs
+ */
+export function getMcpProviderIds() {
+  return Object.keys(mcpProviders);
+}
+
+/**
+ * Get MCP provider by ID
+ */
+export function getMcpProvider(id) {
+  return mcpProviders[id];
+}
+
+/**
+ * Get all enabled MCP providers
+ */
+export function getEnabledMcpProviders(config = {}) {
+  const enabledProviders = config.enabledMcpProviders || getMcpProviderIds();
+  return enabledProviders.map(id => mcpProviders[id]).filter(Boolean);
+}
+
+/**
+ * Standard MCP server config format (most providers use this)
+ */
+export function createMcpServerConfig(name, command, args = [], env = {}) {
+  return {
+    [name]: {
+      command,
+      args,
+      ...(Object.keys(env).length > 0 ? { env } : {})
+    }
+  };
+}