ai-agent-config 1.0.0

package/README.md

@@ -0,0 +1,115 @@
+# AI Agent Config
+
+> Universal Global Skills & Workflows for AI Coding Assistants
+
+[![npm version](https://badge.fury.io/js/@dongitran%2Fai-agent-config.svg)](https://www.npmjs.com/package/@dongitran/ai-agent-config)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Install a curated collection of AI agent skills from [github.com/dongitran/ai-agent-config](https://github.com/dongitran/ai-agent-config) to your global configuration.
+
+## How It Works
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  GitHub Repository                                              │
+│  github.com/dongitran/ai-agent-config                           │
+│  └── .agent/                                                    │
+│      ├── skills/         ◄── Skills are defined here            │
+│      │   ├── code-review/                                       │
+│      │   └── git-commit/                                        │
+│      └── workflows/                                             │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              │ ai-agent sync
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│  Local Cache                                                    │
+│  ~/.ai-agent-config-cache/                                      │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              │ ai-agent install
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│  Platform Global Directories                                    │
+│  ├── ~/.claude/skills/           (Claude Code)                  │
+│  ├── ~/.gemini/antigravity/skills/ (Antigravity IDE)            │
+│  ├── ~/.cursor/skills/           (Cursor)                       │
+│  └── ~/.windsurf/skills/         (Windsurf)                     │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Installation
+
+```bash
+# Install the CLI globally
+npm install -g @dongitran/ai-agent-config
+
+# Sync skills from repository
+ai-agent sync
+
+# Install to your platforms
+ai-agent install
+```
+
+## CLI Usage
+
+```bash
+ai-agent help          # Show all commands
+ai-agent sync          # Sync from GitHub repository
+ai-agent install       # Install to all detected platforms
+ai-agent list          # List available skills
+ai-agent platforms     # Show detected platforms
+ai-agent uninstall     # Remove installed skills
+```
+
+### Options
+
+```bash
+ai-agent install --platform claude   # Install to specific platform
+ai-agent install --skill code-review # Install specific skill
+ai-agent install --force             # Overwrite existing files
+```
+
+## Supported Platforms
+
+| Platform | Global Skills Path |
+|----------|-------------------|
+| Claude Code | `~/.claude/skills/` |
+| Antigravity IDE | `~/.gemini/antigravity/skills/` |
+| Cursor | `~/.cursor/skills/` |
+| Windsurf | `~/.windsurf/skills/` |
+| Codex CLI | `~/.codex/skills/` |
+
+## Available Skills
+
+Skills are defined in the repository's `.agent/skills/` directory:
+
+- **code-review** - Thorough code review with security, performance checks
+- **git-commit** - Conventional commit message formatting
+- *More coming soon...*
+
+## Configuration
+
+Optional config at `~/.ai-agent-config.json`:
+
+```json
+{
+  "platforms": ["claude", "antigravity"],
+  "skills": {
+    "include": ["*"],
+    "exclude": []
+  }
+}
+```
+
+## Contributing
+
+Add your skills to the repository:
+
+1. Fork [github.com/dongitran/ai-agent-config](https://github.com/dongitran/ai-agent-config)
+2. Create skill in `.agent/skills/your-skill/SKILL.md`
+3. Submit a pull request
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,297 @@
+#!/usr/bin/env node
+
+/**
+ * AI Agent Config CLI
+ * Install global skills from https://github.com/dongitran/ai-agent-config
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+const platforms = require("../scripts/platforms");
+const installer = require("../scripts/installer");
+
+const COMMANDS = {
+  init: "Initialize config file in home directory",
+  install: "Install skills to detected platforms",
+  sync: "Sync skills from GitHub repository",
+  list: "List available skills and workflows",
+  platforms: "Show detected platforms",
+  uninstall: "Remove installed skills",
+  help: "Show this help message",
+};
+
+function showHelp() {
+  console.log(`
+╔═══════════════════════════════════════════════════════════════╗
+║               AI Agent Config CLI                             ║
+║   Universal Global Skills for AI Coding Assistants            ║
+╚═══════════════════════════════════════════════════════════════╝
+
+Usage: ai-agent <command> [options]
+
+Commands:`);
+
+  Object.entries(COMMANDS).forEach(([cmd, desc]) => {
+    console.log(`  ${cmd.padEnd(12)} ${desc}`);
+  });
+
+  console.log(`
+Options:
+  --platform <name>   Target specific platform (claude, antigravity, cursor)
+  --skill <name>      Install specific skill only
+  --force             Overwrite existing files
+
+Examples:
+  ai-agent sync                    # Sync from GitHub repository
+  ai-agent install                 # Install all skills to detected platforms
+  ai-agent install --platform claude
+  ai-agent install --skill code-review
+  ai-agent list                    # List available skills
+  ai-agent platforms               # Show detected platforms
+  ai-agent uninstall               # Remove all installed skills
+
+Repository: https://github.com/dongitran/ai-agent-config
+Skills are stored in: ~/.ai-agent-config-cache/.agent/skills/
+`);
+}
+
+function showPlatforms() {
+  console.log("\n🔍 Detecting platforms...\n");
+
+  const detected = platforms.detectAll();
+
+  if (detected.length === 0) {
+    console.log("No AI coding platforms detected in home directory.\n");
+    console.log("Supported platforms:");
+    platforms.SUPPORTED.forEach((p) => {
+      console.log(`  - ${p.displayName} (~/${p.configDir})`);
+    });
+    return;
+  }
+
+  console.log("Detected platforms:\n");
+  detected.forEach((p) => {
+    console.log(`  ✓ ${p.displayName}`);
+    console.log(`    Skills: ${p.skillsPath}`);
+    console.log("");
+  });
+}
+
+function listSkills() {
+  console.log("\n📦 Available Skills & Workflows\n");
+
+  if (!installer.isRepoCached()) {
+    console.log("⚠️  Repository not synced yet.");
+    console.log("   Run: ai-agent sync\n");
+    return;
+  }
+
+  const skills = installer.getAvailableSkills();
+  const workflows = installer.getAvailableWorkflows();
+
+  console.log("Skills:");
+  if (skills.length === 0) {
+    console.log("  (no skills found)");
+  } else {
+    skills.forEach((skill) => {
+      const skillFile = path.join(installer.REPO_SKILLS_DIR, skill, "SKILL.md");
+      let desc = "";
+      if (fs.existsSync(skillFile)) {
+        const content = fs.readFileSync(skillFile, "utf-8");
+        const match = content.match(/description:\s*(.+)/i);
+        if (match) desc = `- ${match[1]}`;
+      }
+      console.log(`  • ${skill} ${desc}`);
+    });
+  }
+
+  console.log("\nWorkflows:");
+  if (workflows.length === 0) {
+    console.log("  (no workflows found)");
+  } else {
+    workflows.forEach((wf) => {
+      console.log(`  • ${wf}`);
+    });
+  }
+
+  console.log(`\nSource: ${installer.CACHE_DIR}`);
+  console.log("");
+}
+
+function init(args) {
+  console.log("\n🚀 Initializing AI Agent Config...\n");
+
+  const configFile = path.join(platforms.HOME, ".ai-agent-config.json");
+
+  if (fs.existsSync(configFile) && !args.includes("--force")) {
+    console.log("⚠️  Config file already exists. Use --force to overwrite.");
+    return;
+  }
+
+  const defaultConfig = {
+    platforms: ["auto"],
+    skills: {
+      include: ["*"],
+      exclude: [],
+    },
+    sync: {
+      auto: false,
+      remote: "https://github.com/dongitran/ai-agent-config",
+    },
+  };
+
+  fs.writeFileSync(configFile, JSON.stringify(defaultConfig, null, 2));
+  console.log(`✓ Created ${configFile}`);
+
+  const detected = platforms.detectAll();
+  if (detected.length > 0) {
+    console.log("\nDetected platforms:");
+    detected.forEach((p) => console.log(`  ✓ ${p.displayName}`));
+  }
+
+  console.log("\nNext steps:");
+  console.log("  1. Run: ai-agent sync");
+  console.log("  2. Run: ai-agent install");
+  console.log("");
+}
+
+function install(args) {
+  console.log("\n📥 Installing skills...\n");
+
+  const options = {
+    platform: null,
+    force: false,
+    skill: null,
+    sync: true,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--platform" && args[i + 1]) {
+      options.platform = args[++i];
+    } else if (args[i] === "--force") {
+      options.force = true;
+    } else if (args[i] === "--skill" && args[i + 1]) {
+      options.skill = args[++i];
+    } else if (args[i] === "--no-sync") {
+      options.sync = false;
+    }
+  }
+
+  try {
+    const result = installer.install(options);
+
+    if (result.skillsCount > 0) {
+      console.log(`\n✓ Installed ${result.skillsCount} skill(s) to ${result.platformsCount} platform(s)\n`);
+      result.details.forEach((d) => {
+        console.log(`  ${d.platform}: ${d.path}`);
+        d.skills.forEach((s) => {
+          const status = s.skipped > 0 ? `(${s.copied} new, ${s.skipped} skipped)` : "";
+          console.log(`    • ${s.name} ${status}`);
+        });
+      });
+    } else {
+      console.log("\n⚠️  No skills installed.");
+    }
+  } catch (error) {
+    console.error(`\n❌ Installation failed: ${error.message}`);
+    process.exit(1);
+  }
+
+  console.log("");
+}
+
+function sync(args) {
+  console.log("\n🔄 Syncing from GitHub repository...\n");
+  console.log(`   Repository: ${installer.REPO_URL}`);
+  console.log(`   Cache: ${installer.CACHE_DIR}\n`);
+
+  try {
+    const success = installer.syncRepo();
+
+    if (success) {
+      console.log("\n✓ Sync complete!\n");
+
+      const skills = installer.getAvailableSkills();
+      const workflows = installer.getAvailableWorkflows();
+
+      console.log(`   Found ${skills.length} skill(s), ${workflows.length} workflow(s)`);
+      console.log("\n   Run 'ai-agent install' to install to your platforms.\n");
+    }
+  } catch (error) {
+    console.error(`\n❌ Sync failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+function uninstall(args) {
+  console.log("\n🗑️  Uninstalling skills...\n");
+
+  const options = {
+    platform: null,
+    skill: null,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--platform" && args[i + 1]) {
+      options.platform = args[++i];
+    } else if (args[i] === "--skill" && args[i + 1]) {
+      options.skill = args[++i];
+    }
+  }
+
+  try {
+    const result = installer.uninstall(options);
+
+    if (result.totalRemoved > 0) {
+      console.log(`✓ Removed ${result.totalRemoved} skill(s) from ${result.platformsCount} platform(s)\n`);
+      result.details.forEach((d) => {
+        if (d.removed > 0) {
+          console.log(`  ${d.platform}: ${d.removed} removed`);
+        }
+      });
+    } else {
+      console.log("ℹ️  No skills to remove.");
+    }
+  } catch (error) {
+    console.error(`\n❌ Uninstall failed: ${error.message}`);
+    process.exit(1);
+  }
+
+  console.log("");
+}
+
+// Main
+const args = process.argv.slice(2);
+const command = args[0];
+
+switch (command) {
+  case "init":
+    init(args.slice(1));
+    break;
+  case "install":
+    install(args.slice(1));
+    break;
+  case "sync":
+    sync(args.slice(1));
+    break;
+  case "list":
+    listSkills();
+    break;
+  case "platforms":
+    showPlatforms();
+    break;
+  case "uninstall":
+    uninstall(args.slice(1));
+    break;
+  case "help":
+  case "--help":
+  case "-h":
+  case undefined:
+    showHelp();
+    break;
+  default:
+    console.error(`Unknown command: ${command}`);
+    console.log('Run "ai-agent help" for usage information.');
+    process.exit(1);
+}

package/index.js

@@ -0,0 +1,36 @@
+/**
+ * AI Agent Config
+ * Universal Global Skills & Workflows for AI Coding Assistants
+ *
+ * @module @dongitran/ai-agent-config
+ */
+
+const platforms = require("./scripts/platforms");
+const installer = require("./scripts/installer");
+
+module.exports = {
+  // Platform detection
+  platforms: {
+    detectAll: platforms.detectAll,
+    getByName: platforms.getByName,
+    getAllNames: platforms.getAllNames,
+    SUPPORTED: platforms.SUPPORTED,
+  },
+
+  // Installation
+  installer: {
+    install: installer.install,
+    uninstall: installer.uninstall,
+    syncRepo: installer.syncRepo,
+    isRepoCached: installer.isRepoCached,
+    getAvailableSkills: installer.getAvailableSkills,
+    getAvailableWorkflows: installer.getAvailableWorkflows,
+  },
+
+  // Constants
+  REPO_URL: installer.REPO_URL,
+  CACHE_DIR: installer.CACHE_DIR,
+
+  // Version
+  version: require("./package.json").version,
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "ai-agent-config",
+  "version": "1.0.0",
+  "description": "Universal Global Skills & Workflows for AI Coding Assistants (Claude Code, Antigravity, Cursor)",
+  "main": "index.js",
+  "bin": {
+    "ai-agent": "./bin/cli.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "test": "node --test"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "skills",
+    "claude-code",
+    "antigravity",
+    "cursor",
+    "windsurf",
+    "copilot",
+    "workflows",
+    "coding-assistant",
+    "global-skills"
+  ],
+  "author": "Dong Tran",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dongitran/ai-agent-config.git"
+  },
+  "bugs": {
+    "url": "https://github.com/dongitran/ai-agent-config/issues"
+  },
+  "homepage": "https://github.com/dongitran/ai-agent-config#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "index.js"
+  ]
+}

package/scripts/installer.js

@@ -0,0 +1,280 @@
+/**
+ * Installer module for AI Agent Config
+ * Handles syncing from GitHub repo and copying skills to platform directories
+ */
+
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+const platforms = require("./platforms");
+
+const REPO_URL = "https://github.com/dongitran/ai-agent-config.git";
+const CACHE_DIR = path.join(platforms.HOME, ".ai-agent-config-cache");
+const REPO_SKILLS_DIR = path.join(CACHE_DIR, ".agent", "skills");
+const REPO_WORKFLOWS_DIR = path.join(CACHE_DIR, ".agent", "workflows");
+
+/**
+ * Copy directory recursively
+ */
+function copyDir(src, dest, force = false) {
+  if (!fs.existsSync(src)) {
+    return { copied: 0, skipped: 0 };
+  }
+
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  let copied = 0;
+  let skipped = 0;
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      const result = copyDir(srcPath, destPath, force);
+      copied += result.copied;
+      skipped += result.skipped;
+    } else {
+      if (fs.existsSync(destPath) && !force) {
+        skipped++;
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+        copied++;
+      }
+    }
+  }
+
+  return { copied, skipped };
+}
+
+/**
+ * Sync repository from GitHub
+ * @returns {boolean} Success status
+ */
+function syncRepo() {
+  try {
+    if (fs.existsSync(CACHE_DIR)) {
+      console.log("   Updating cached repository...");
+      execSync("git pull --quiet", { cwd: CACHE_DIR, stdio: "pipe" });
+    } else {
+      console.log("   Cloning repository...");
+      execSync(`git clone --quiet "${REPO_URL}" "${CACHE_DIR}"`, { stdio: "pipe" });
+    }
+    return true;
+  } catch (error) {
+    console.error(`   Failed to sync: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Check if repo is cached
+ */
+function isRepoCached() {
+  return fs.existsSync(CACHE_DIR) && fs.existsSync(REPO_SKILLS_DIR);
+}
+
+/**
+ * Get list of available skills from cached repo
+ */
+function getAvailableSkills() {
+  if (!fs.existsSync(REPO_SKILLS_DIR)) {
+    return [];
+  }
+
+  return fs.readdirSync(REPO_SKILLS_DIR).filter((name) => {
+    const skillPath = path.join(REPO_SKILLS_DIR, name);
+    const skillFile = path.join(skillPath, "SKILL.md");
+    return fs.statSync(skillPath).isDirectory() && fs.existsSync(skillFile);
+  });
+}
+
+/**
+ * Get list of available workflows from cached repo
+ */
+function getAvailableWorkflows() {
+  if (!fs.existsSync(REPO_WORKFLOWS_DIR)) {
+    return [];
+  }
+
+  return fs
+    .readdirSync(REPO_WORKFLOWS_DIR)
+    .filter((name) => name.endsWith(".md"))
+    .map((name) => name.replace(".md", ""));
+}
+
+/**
+ * Install skills to a specific platform
+ */
+function installToPlatform(platform, options = {}) {
+  const { force = false, skill = null } = options;
+
+  const skillsPath = platforms.ensureSkillsDir(platform);
+  const results = { platform: platform.name, path: skillsPath, skills: [] };
+
+  let skillsToInstall = getAvailableSkills();
+
+  if (skill) {
+    skillsToInstall = skillsToInstall.filter((s) => s === skill);
+    if (skillsToInstall.length === 0) {
+      throw new Error(`Skill "${skill}" not found in repository`);
+    }
+  }
+
+  for (const skillName of skillsToInstall) {
+    const srcPath = path.join(REPO_SKILLS_DIR, skillName);
+    const destPath = path.join(skillsPath, skillName);
+
+    const copyResult = copyDir(srcPath, destPath, force);
+    results.skills.push({
+      name: skillName,
+      ...copyResult,
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Install skills to all detected platforms
+ */
+function install(options = {}) {
+  const { platform = null, force = false, skill = null, sync = true } = options;
+
+  // Sync repo first if needed
+  if (sync && !isRepoCached()) {
+    console.log("\n📦 Syncing skills from repository...");
+    if (!syncRepo()) {
+      throw new Error("Failed to sync repository. Check your internet connection.");
+    }
+  }
+
+  if (!isRepoCached()) {
+    console.log("\n⚠️  Skills repository not cached. Run 'ai-agent sync' first.");
+    return { skillsCount: 0, platformsCount: 0, details: [] };
+  }
+
+  let targetPlatforms;
+
+  if (platform) {
+    const platformObj = platforms.getByName(platform);
+    if (!platformObj) {
+      throw new Error(
+        `Unknown platform: ${platform}. Available: ${platforms.getAllNames().join(", ")}`
+      );
+    }
+    targetPlatforms = [platformObj];
+  } else {
+    targetPlatforms = platforms.detectAll().map((p) => platforms.getByName(p.name));
+  }
+
+  if (targetPlatforms.length === 0) {
+    console.log("\n⚠️  No AI coding platforms detected.");
+    console.log("   Supported platforms:", platforms.getAllNames().join(", "));
+    console.log("\n   Force install with: ai-agent install --platform <name>");
+    return { skillsCount: 0, platformsCount: 0, details: [] };
+  }
+
+  const details = [];
+  let totalSkills = 0;
+
+  for (const platformObj of targetPlatforms) {
+    try {
+      const result = installToPlatform(platformObj, { force, skill });
+      details.push(result);
+      totalSkills += result.skills.length;
+    } catch (error) {
+      console.error(`   Failed to install to ${platformObj.name}: ${error.message}`);
+    }
+  }
+
+  return {
+    skillsCount: totalSkills,
+    platformsCount: details.length,
+    details,
+  };
+}
+
+/**
+ * Uninstall skills from a platform
+ */
+function uninstallFromPlatform(platform, skill = null) {
+  const skillsPath = platform.skillsPath;
+
+  if (!fs.existsSync(skillsPath)) {
+    return { platform: platform.name, removed: 0 };
+  }
+
+  let removed = 0;
+  const ourSkills = getAvailableSkills();
+
+  if (skill) {
+    const skillPath = path.join(skillsPath, skill);
+    if (fs.existsSync(skillPath) && ourSkills.includes(skill)) {
+      fs.rmSync(skillPath, { recursive: true });
+      removed++;
+    }
+  } else {
+    for (const skillName of ourSkills) {
+      const skillPath = path.join(skillsPath, skillName);
+      if (fs.existsSync(skillPath)) {
+        fs.rmSync(skillPath, { recursive: true });
+        removed++;
+      }
+    }
+  }
+
+  return { platform: platform.name, removed };
+}
+
+/**
+ * Uninstall skills from all platforms
+ */
+function uninstall(options = {}) {
+  const { platform = null, skill = null } = options;
+
+  let targetPlatforms;
+
+  if (platform) {
+    const platformObj = platforms.getByName(platform);
+    if (!platformObj) {
+      throw new Error(`Unknown platform: ${platform}`);
+    }
+    targetPlatforms = [platformObj];
+  } else {
+    targetPlatforms = platforms.detectAll().map((p) => platforms.getByName(p.name));
+  }
+
+  const results = [];
+  let totalRemoved = 0;
+
+  for (const platformObj of targetPlatforms) {
+    const result = uninstallFromPlatform(platformObj, skill);
+    results.push(result);
+    totalRemoved += result.removed;
+  }
+
+  return {
+    totalRemoved,
+    platformsCount: results.length,
+    details: results,
+  };
+}
+
+module.exports = {
+  install,
+  uninstall,
+  syncRepo,
+  isRepoCached,
+  getAvailableSkills,
+  getAvailableWorkflows,
+  copyDir,
+  CACHE_DIR,
+  REPO_URL,
+  REPO_SKILLS_DIR,
+  REPO_WORKFLOWS_DIR,
+};

package/scripts/platforms.js

@@ -0,0 +1,182 @@
+/**
+ * Platform detection for AI coding assistants
+ * Detects which platforms are installed and returns their global skills paths
+ */
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const HOME = os.homedir();
+
+/**
+ * Supported platforms configuration
+ */
+const SUPPORTED = [
+  {
+    name: "claude",
+    displayName: "Claude Code",
+    configDir: ".claude",
+    skillsDir: "skills",
+    commandsDir: "commands",
+    get configPath() {
+      return path.join(HOME, this.configDir);
+    },
+    get skillsPath() {
+      return path.join(HOME, this.configDir, this.skillsDir);
+    },
+    get commandsPath() {
+      return path.join(HOME, this.configDir, this.commandsDir);
+    },
+    detect() {
+      return fs.existsSync(this.configPath);
+    },
+  },
+  {
+    name: "antigravity",
+    displayName: "Antigravity IDE",
+    configDir: ".gemini/antigravity",
+    skillsDir: "skills",
+    workflowsDir: "workflows",
+    get configPath() {
+      return path.join(HOME, this.configDir);
+    },
+    get skillsPath() {
+      return path.join(HOME, this.configDir, this.skillsDir);
+    },
+    get workflowsPath() {
+      return path.join(HOME, this.configDir, this.workflowsDir);
+    },
+    detect() {
+      // Check for .gemini directory or Antigravity app
+      return (
+        fs.existsSync(path.join(HOME, ".gemini")) ||
+        fs.existsSync("/Applications/Antigravity.app") ||
+        fs.existsSync(path.join(HOME, "Applications", "Antigravity.app"))
+      );
+    },
+  },
+  {
+    name: "cursor",
+    displayName: "Cursor",
+    configDir: ".cursor",
+    skillsDir: "skills",
+    rulesDir: "rules",
+    get configPath() {
+      return path.join(HOME, this.configDir);
+    },
+    get skillsPath() {
+      return path.join(HOME, this.configDir, this.skillsDir);
+    },
+    get rulesPath() {
+      return path.join(HOME, this.configDir, this.rulesDir);
+    },
+    detect() {
+      return (
+        fs.existsSync(this.configPath) ||
+        fs.existsSync("/Applications/Cursor.app") ||
+        fs.existsSync(path.join(HOME, "Applications", "Cursor.app"))
+      );
+    },
+  },
+  {
+    name: "windsurf",
+    displayName: "Windsurf",
+    configDir: ".windsurf",
+    skillsDir: "skills",
+    get configPath() {
+      return path.join(HOME, this.configDir);
+    },
+    get skillsPath() {
+      return path.join(HOME, this.configDir, this.skillsDir);
+    },
+    detect() {
+      return (
+        fs.existsSync(this.configPath) ||
+        fs.existsSync("/Applications/Windsurf.app")
+      );
+    },
+  },
+  {
+    name: "codex",
+    displayName: "Codex CLI",
+    configDir: ".codex",
+    skillsDir: "skills",
+    get configPath() {
+      return path.join(HOME, this.configDir);
+    },
+    get skillsPath() {
+      return path.join(HOME, this.configDir, this.skillsDir);
+    },
+    detect() {
+      return fs.existsSync(this.configPath);
+    },
+  },
+  {
+    name: "copilot",
+    displayName: "GitHub Copilot",
+    configDir: ".github",
+    instructionsFile: "copilot-instructions.md",
+    get configPath() {
+      return path.join(HOME, this.configDir);
+    },
+    get instructionsPath() {
+      return path.join(HOME, this.configDir, this.instructionsFile);
+    },
+    detect() {
+      // Copilot is usually detected via VS Code extensions
+      return fs.existsSync(this.configPath);
+    },
+  },
+];
+
+/**
+ * Detect all installed platforms
+ * @returns {Array} Array of detected platform objects
+ */
+function detectAll() {
+  return SUPPORTED.filter((platform) => platform.detect()).map((platform) => ({
+    name: platform.name,
+    displayName: platform.displayName,
+    configPath: platform.configPath,
+    skillsPath: platform.skillsPath,
+  }));
+}
+
+/**
+ * Get platform by name
+ * @param {string} name - Platform name
+ * @returns {Object|null} Platform object or null
+ */
+function getByName(name) {
+  return SUPPORTED.find((p) => p.name === name.toLowerCase()) || null;
+}
+
+/**
+ * Ensure skills directory exists for a platform
+ * @param {Object} platform - Platform object
+ */
+function ensureSkillsDir(platform) {
+  const skillsPath = platform.skillsPath;
+  if (!fs.existsSync(skillsPath)) {
+    fs.mkdirSync(skillsPath, { recursive: true });
+  }
+  return skillsPath;
+}
+
+/**
+ * Get all supported platform names
+ * @returns {Array} Array of platform names
+ */
+function getAllNames() {
+  return SUPPORTED.map((p) => p.name);
+}
+
+module.exports = {
+  SUPPORTED,
+  detectAll,
+  getByName,
+  ensureSkillsDir,
+  getAllNames,
+  HOME,
+};

package/scripts/postinstall.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+/**
+ * Post-install script for AI Agent Config
+ * Shows usage instructions after npm install
+ */
+
+const platforms = require("./platforms");
+
+function main() {
+  console.log("\n╔═══════════════════════════════════════════════════════════════╗");
+  console.log("║               AI Agent Config Installed!                      ║");
+  console.log("╚═══════════════════════════════════════════════════════════════╝\n");
+
+  // Detect platforms
+  const detected = platforms.detectAll();
+
+  if (detected.length > 0) {
+    console.log("🔍 Detected platforms:\n");
+    detected.forEach((p) => {
+      console.log(`   ✓ ${p.displayName}`);
+    });
+    console.log("");
+  }
+
+  console.log("📖 Quick Start:\n");
+  console.log("   1. Sync skills from repository:");
+  console.log("      $ ai-agent sync\n");
+  console.log("   2. Install to your platforms:");
+  console.log("      $ ai-agent install\n");
+  console.log("   3. View available skills:");
+  console.log("      $ ai-agent list\n");
+  console.log("📦 Repository: https://github.com/dongitran/ai-agent-config\n");
+}
+
+main();