antikit 1.0.1

package/README.md

@@ -0,0 +1,65 @@
+# antikit
+
+CLI tool to manage AI agent skills from the [antiskills](https://github.com/vunamhung/antiskills) repository.
+
+## Installation
+
+```bash
+npm install -g antikit
+```
+
+## Usage
+
+### List available skills from remote
+
+```bash
+antikit list
+# or
+antikit ls
+
+# Search skills by name
+antikit list -s <query>
+```
+
+### List installed local skills
+
+```bash
+antikit local
+# or
+antikit l
+```
+
+### Install a skill
+
+```bash
+antikit install <skill-name>
+# or
+antikit i <skill-name>
+
+# Force overwrite if exists
+antikit install <skill-name> --force
+```
+
+### Remove a skill
+
+```bash
+antikit remove <skill-name>
+# or
+antikit rm <skill-name>
+```
+
+## Requirements
+
+- Node.js >= 18.0.0
+- Git (for installing skills)
+- A project with `.agent/skills` directory
+
+## How it works
+
+1. Skills are fetched from the `vunamhung/antiskills` GitHub repository
+2. Each skill is a folder containing a `SKILL.md` file with YAML frontmatter
+3. Skills are installed to the nearest `.agent/skills` directory in your project
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "antikit",
+  "version": "1.0.1",
+  "description": "CLI tool to manage AI agent skills from Anti Gravity skills repository",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "antikit": "src/index.js"
+  },
+  "scripts": {
+    "test": "node src/index.js --help"
+  },
+  "keywords": [
+    "cli",
+    "skills",
+    "ai",
+    "agent",
+    "claude",
+    "gemini",
+    "llm"
+  ],
+  "author": "vunamhung",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vunamhung/antikit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/vunamhung/antikit/issues"
+  },
+  "homepage": "https://github.com/vunamhung/antikit#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "src/**/*"
+  ],
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "ora": "^8.1.1",
+    "simple-git": "^3.27.0"
+  }
+}

package/src/commands/install.js

@@ -0,0 +1,77 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync, cpSync, rmSync } from 'fs';
+import { join } from 'path';
+import { CONFIG } from '../config.js';
+import { findLocalSkillsDir, skillExists } from '../utils/local.js';
+import { fetchRemoteSkills } from '../utils/github.js';
+
+export async function installSkill(skillName, options) {
+    const skillsDir = findLocalSkillsDir();
+
+    if (!skillsDir) {
+        console.log(chalk.red('No .agent/skills directory found in current path.'));
+        console.log(chalk.dim('Make sure you are in a project with .agent/skills folder.'));
+        process.exit(1);
+    }
+
+    // Check if skill already exists
+    if (skillExists(skillName) && !options.force) {
+        console.log(chalk.yellow(`Skill "${skillName}" already exists.`));
+        console.log(chalk.dim(`Use ${chalk.white('--force')} to overwrite.`));
+        return;
+    }
+
+    // Verify skill exists in remote
+    const spinner = ora(`Checking if "${skillName}" exists...`).start();
+
+    try {
+        const remoteSkills = await fetchRemoteSkills();
+        const skillInfo = remoteSkills.find(s => s.name === skillName);
+
+        if (!skillInfo) {
+            spinner.fail(`Skill "${skillName}" not found in remote repository`);
+            console.log(chalk.dim(`Use ${chalk.white('antikit list')} to see available skills`));
+            process.exit(1);
+        }
+
+        spinner.text = `Cloning ${skillName}...`;
+
+        // Clone to temp directory
+        const tempDir = join(CONFIG.CACHE_DIR, 'temp', Date.now().toString());
+        mkdirSync(tempDir, { recursive: true });
+
+        // Sparse checkout only the skill folder
+        execSync(`git clone --depth 1 --filter=blob:none --sparse ${CONFIG.REPO_URL} repo`, {
+            cwd: tempDir,
+            stdio: 'pipe'
+        });
+
+        execSync(`git sparse-checkout set ${skillName}`, {
+            cwd: join(tempDir, 'repo'),
+            stdio: 'pipe'
+        });
+
+        // Copy skill to local
+        const sourcePath = join(tempDir, 'repo', skillName);
+        const destPath = join(skillsDir, skillName);
+
+        if (options.force && existsSync(destPath)) {
+            rmSync(destPath, { recursive: true, force: true });
+        }
+
+        cpSync(sourcePath, destPath, { recursive: true });
+
+        // Cleanup temp
+        rmSync(tempDir, { recursive: true, force: true });
+
+        spinner.succeed(`Installed ${chalk.cyan.bold(skillName)}`);
+        console.log(chalk.dim(`  → ${destPath}`));
+
+    } catch (error) {
+        spinner.fail(`Failed to install "${skillName}"`);
+        console.error(chalk.red(error.message));
+        process.exit(1);
+    }
+}

package/src/commands/list.js

@@ -0,0 +1,60 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { fetchRemoteSkills, fetchSkillInfo } from '../utils/github.js';
+import { skillExists } from '../utils/local.js';
+
+export async function listRemoteSkills(options) {
+    const spinner = ora('Fetching skills from remote...').start();
+
+    try {
+        let skills = await fetchRemoteSkills();
+
+        // Filter by search query
+        if (options.search) {
+            const query = options.search.toLowerCase();
+            skills = skills.filter(s => s.name.toLowerCase().includes(query));
+        }
+
+        spinner.succeed(`Found ${skills.length} skills`);
+        console.log();
+
+        if (skills.length === 0) {
+            console.log(chalk.yellow('No skills found.'));
+            return;
+        }
+
+        // Fetch descriptions
+        const infoSpinner = ora('Fetching skill info...').start();
+        const skillsWithInfo = await Promise.all(
+            skills.map(async (skill) => {
+                const description = await fetchSkillInfo(skill.name);
+                const installed = skillExists(skill.name);
+                return { ...skill, description, installed };
+            })
+        );
+        infoSpinner.stop();
+
+        // Display
+        console.log(chalk.bold('Available Skills:'));
+        console.log(chalk.dim('─'.repeat(60)));
+
+        for (const skill of skillsWithInfo) {
+            const status = skill.installed
+                ? chalk.green(' ✓')
+                : chalk.dim('  ');
+
+            console.log(`${status} ${chalk.cyan.bold(skill.name)}`);
+            if (skill.description) {
+                console.log(`   ${chalk.dim(skill.description)}`);
+            }
+        }
+
+        console.log();
+        console.log(chalk.dim(`Use ${chalk.white('antikit install <skill>')} to install a skill`));
+
+    } catch (error) {
+        spinner.fail('Failed to fetch skills');
+        console.error(chalk.red(error.message));
+        process.exit(1);
+    }
+}

package/src/commands/local.js

@@ -0,0 +1,33 @@
+import chalk from 'chalk';
+import { getLocalSkills, findLocalSkillsDir } from '../utils/local.js';
+
+export async function listLocalSkills() {
+    const skillsDir = findLocalSkillsDir();
+
+    if (!skillsDir) {
+        console.log(chalk.yellow('No .agent/skills directory found in current path.'));
+        console.log(chalk.dim('Make sure you are in a project with .agent/skills folder.'));
+        return;
+    }
+
+    const skills = getLocalSkills();
+
+    if (skills.length === 0) {
+        console.log(chalk.yellow('No skills installed.'));
+        console.log(chalk.dim(`Use ${chalk.white('antikit install <skill>')} to install a skill`));
+        return;
+    }
+
+    console.log(chalk.bold(`Installed Skills (${skills.length}):`));
+    console.log(chalk.dim('─'.repeat(60)));
+
+    for (const skill of skills) {
+        console.log(`  ${chalk.cyan.bold(skill.name)}`);
+        if (skill.description) {
+            console.log(`   ${chalk.dim(skill.description)}`);
+        }
+    }
+
+    console.log();
+    console.log(chalk.dim(`Skills directory: ${skillsDir}`));
+}

package/src/commands/remove.js

@@ -0,0 +1,24 @@
+import chalk from 'chalk';
+import { removeLocalSkill, skillExists, findLocalSkillsDir } from '../utils/local.js';
+
+export async function removeSkill(skillName) {
+    const skillsDir = findLocalSkillsDir();
+
+    if (!skillsDir) {
+        console.log(chalk.red('No .agent/skills directory found in current path.'));
+        process.exit(1);
+    }
+
+    if (!skillExists(skillName)) {
+        console.log(chalk.yellow(`Skill "${skillName}" is not installed.`));
+        process.exit(1);
+    }
+
+    try {
+        removeLocalSkill(skillName);
+        console.log(chalk.green(`✓ Removed ${chalk.bold(skillName)}`));
+    } catch (error) {
+        console.error(chalk.red(`Failed to remove: ${error.message}`));
+        process.exit(1);
+    }
+}

package/src/config.js

@@ -0,0 +1,17 @@
+import { homedir } from 'os';
+import { join } from 'path';
+
+export const CONFIG = {
+    // Remote repository
+    REPO_OWNER: 'vunamhung',
+    REPO_NAME: 'antiskills',
+    REPO_URL: 'https://github.com/vunamhung/antiskills.git',
+    GITHUB_API: 'https://api.github.com',
+
+    // Local paths
+    LOCAL_SKILLS_DIR: '.agent/skills',
+
+    // Cache
+    CACHE_DIR: join(homedir(), '.antikit'),
+    CACHE_TTL: 1000 * 60 * 60, // 1 hour
+};

package/src/index.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { listRemoteSkills } from './commands/list.js';
+import { listLocalSkills } from './commands/local.js';
+import { installSkill } from './commands/install.js';
+import { removeSkill } from './commands/remove.js';
+
+const program = new Command();
+
+program
+  .name('antikit')
+  .description('CLI tool to manage skills from antiskills repository')
+  .version('1.0.0');
+
+program
+  .command('list')
+  .alias('ls')
+  .description('List available skills from remote repository')
+  .option('-s, --search <query>', 'Search skills by name')
+  .action(listRemoteSkills);
+
+program
+  .command('local')
+  .alias('l')
+  .description('List installed skills in local .agent/skills directory')
+  .action(listLocalSkills);
+
+program
+  .command('install <skill>')
+  .alias('i')
+  .description('Install a skill from remote repository')
+  .option('-f, --force', 'Force overwrite if skill already exists')
+  .action(installSkill);
+
+program
+  .command('remove <skill>')
+  .alias('rm')
+  .description('Remove an installed skill')
+  .action(removeSkill);
+
+program.parse();

package/src/utils/github.js

@@ -0,0 +1,67 @@
+import { CONFIG } from '../config.js';
+
+/**
+ * Fetch list of skills (directories) from GitHub repo
+ */
+export async function fetchRemoteSkills() {
+    const url = `${CONFIG.GITHUB_API}/repos/${CONFIG.REPO_OWNER}/${CONFIG.REPO_NAME}/contents`;
+
+    const response = await fetch(url, {
+        headers: {
+            'Accept': 'application/vnd.github.v3+json',
+            'User-Agent': 'antikit-cli'
+        }
+    });
+
+    if (!response.ok) {
+        const data = await response.json().catch(() => ({}));
+        // Handle empty repository
+        if (data.message === 'This repository is empty.') {
+            return [];
+        }
+        throw new Error(`Failed to fetch skills: ${response.statusText}`);
+    }
+
+    const contents = await response.json();
+
+    // Filter only directories (skills)
+    const skills = contents
+        .filter(item => item.type === 'dir' && !item.name.startsWith('.'))
+        .map(item => ({
+            name: item.name,
+            url: item.html_url,
+            path: item.path
+        }));
+
+    return skills;
+}
+
+/**
+ * Fetch SKILL.md content for a specific skill
+ */
+export async function fetchSkillInfo(skillName) {
+    const url = `${CONFIG.GITHUB_API}/repos/${CONFIG.REPO_OWNER}/${CONFIG.REPO_NAME}/contents/${skillName}/SKILL.md`;
+
+    const response = await fetch(url, {
+        headers: {
+            'Accept': 'application/vnd.github.v3+json',
+            'User-Agent': 'antikit-cli'
+        }
+    });
+
+    if (!response.ok) {
+        return null;
+    }
+
+    const data = await response.json();
+    const content = Buffer.from(data.content, 'base64').toString('utf-8');
+
+    // Extract description from YAML frontmatter
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (match) {
+        const descMatch = match[1].match(/description:\s*(.+)/);
+        return descMatch ? descMatch[1].trim() : null;
+    }
+
+    return null;
+}

package/src/utils/local.js

@@ -0,0 +1,84 @@
+import { existsSync, readdirSync, readFileSync, rmSync } from 'fs';
+import { join } from 'path';
+import { CONFIG } from '../config.js';
+
+/**
+ * Find local skills directory by traversing up from cwd
+ */
+export function findLocalSkillsDir() {
+    let dir = process.cwd();
+
+    while (dir !== '/') {
+        const skillsPath = join(dir, CONFIG.LOCAL_SKILLS_DIR);
+        if (existsSync(skillsPath)) {
+            return skillsPath;
+        }
+        dir = join(dir, '..');
+    }
+
+    return null;
+}
+
+/**
+ * Get list of installed skills
+ */
+export function getLocalSkills() {
+    const skillsDir = findLocalSkillsDir();
+
+    if (!skillsDir) {
+        return [];
+    }
+
+    const entries = readdirSync(skillsDir, { withFileTypes: true });
+
+    return entries
+        .filter(entry => entry.isDirectory() && !entry.name.startsWith('.'))
+        .map(entry => {
+            const skillPath = join(skillsDir, entry.name);
+            const skillMdPath = join(skillPath, 'SKILL.md');
+
+            let description = null;
+            if (existsSync(skillMdPath)) {
+                const content = readFileSync(skillMdPath, 'utf-8');
+                const match = content.match(/^---\n([\s\S]*?)\n---/);
+                if (match) {
+                    const descMatch = match[1].match(/description:\s*(.+)/);
+                    description = descMatch ? descMatch[1].trim() : null;
+                }
+            }
+
+            return {
+                name: entry.name,
+                path: skillPath,
+                description
+            };
+        });
+}
+
+/**
+ * Check if skill exists locally
+ */
+export function skillExists(skillName) {
+    const skillsDir = findLocalSkillsDir();
+    if (!skillsDir) return false;
+
+    const skillPath = join(skillsDir, skillName);
+    return existsSync(skillPath);
+}
+
+/**
+ * Remove a skill
+ */
+export function removeLocalSkill(skillName) {
+    const skillsDir = findLocalSkillsDir();
+    if (!skillsDir) {
+        throw new Error('No .agent/skills directory found');
+    }
+
+    const skillPath = join(skillsDir, skillName);
+    if (!existsSync(skillPath)) {
+        throw new Error(`Skill "${skillName}" not found`);
+    }
+
+    rmSync(skillPath, { recursive: true, force: true });
+}