antikit 1.4.0 → 1.6.0

package/README.md

@@ -1,6 +1,6 @@
 # antikit
 
-CLI tool to manage AI agent skills from the [antiskills](https://github.com/vunamhung/antiskills) repository.
+CLI tool to manage AI agent skills from multiple repositories. Easily discover, install, and update skills for your AI agents.
 
 ## Installation
 
@@ -10,8 +10,9 @@ npm install -g antikit
 
 ## Usage
 
-### List available skills from remote
+### 📦 Manage Skills
 
+#### List available skills
 ```bash
 antikit list
 # or
@@ -19,17 +20,16 @@ antikit ls
 
 # Search skills by name
 antikit list -s <query>
-```
 
-### List installed local skills
+# Interactive mode (select and install)
+antikit list -i
 
-```bash
-antikit local
-# or
-antikit l
+# Filter by source
+antikit list --source official
 ```
 
-### Install a skill
+#### Install a skill
+Automatically installs dependencies defined in `SKILL.md`.
 
 ```bash
 antikit install <skill-name>
@@ -40,25 +40,94 @@ antikit i <skill-name>
 antikit install <skill-name> --force
 ```
 
-### Remove a skill
+#### Upgrade installed skills
+Update your local skills to the latest version from their sources.
+
+```bash
+# Upgrade all installed skills
+antikit upgrade
+
+# Upgrade a specific skill
+antikit upgrade <skill-name>
+
+# Upgrade without confirmation (good for scripts)
+antikit upgrade --yes
+```
+
+#### List installed local skills
+```bash
+antikit local
+# or
+antikit l
+```
 
+#### 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
+### 📡 Manage Sources
+You can fetch skills from multiple GitHub repositories.
+
+```bash
+# List configured sources
+antikit source list
 
-## How it works
+# Add a new source (GitHub owner/repo)
+antikit source add vunamhung/another-repo
 
-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
+# Add with a custom name
+antikit source add vunamhung/private-skills --name private
+
+# Set a default source
+antikit source default private
+
+# Remove a source
+antikit source remove private
+```
+
+---
+
+### 🔄 Self Update
+Update the `antikit` CLI tool itself to the latest version.
+
+```bash
+antikit update
+```
+*Note: You will also be notified automatically if a new version is available when running any command.*
+
+---
+
+## Skill Development
+
+### Skill Structure
+A skill is a directory containing a `SKILL.md` file.
+
+### Defining Dependencies
+You can specify dependencies in the `SKILL.md` frontmatter. `antikit` will automatically install them.
+
+```yaml
+---
+name: my-skill
+description: A powerful skill that needs helpers
+dependencies: 
+  - sql-helper
+  - python-runner
+---
+
+# My Skill Content
+...
+```
+
+## Requirements
+
+- Node.js >= 18.0.0
+- Git (for cloning skills)
+- A project with `.agent/skills` directory (created automatically)
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antikit",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "CLI tool to manage AI agent skills from Anti Gravity skills repository",
   "type": "module",
   "main": "src/index.js",

package/src/commands/install.js

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import ora from 'ora';
 import { execSync } from 'child_process';
-import { existsSync, mkdirSync, cpSync, rmSync } from 'fs';
+import { existsSync, mkdirSync, cpSync, rmSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { getOrCreateSkillsDir, skillExists } from '../utils/local.js';
@@ -69,15 +69,96 @@ export async function installSkill(skillName, options = {}) {
         if (!existsSync(sourcePath)) {
             rmSync(tempDir, { recursive: true, force: true });
             spinner.fail(`Skill "${skillName}" not found in ${owner}/${repo}`);
+            if (options.noExit) throw new Error('Skill not found');
             process.exit(1);
         }
 
+        // --- Check dependencies ---
+        try {
+            const mdPath = join(sourcePath, 'SKILL.md');
+            if (existsSync(mdPath)) {
+                // Import locally to avoid cluttering top imports if possible, or just use fs
+                const { readFileSync } = await import('fs');
+                const content = readFileSync(mdPath, 'utf-8');
+
+                // Parse frontmatter dependencies
+                // Supports inline: dependencies: [a, b]
+                // Supports list: 
+                // dependencies:
+                //   - a
+                //   - b
+                let deps = [];
+
+                // Try inline
+                const inlineMatch = content.match(/^dependencies:\s*\[(.*?)\]/m);
+                if (inlineMatch) {
+                    deps = inlineMatch[1].split(',').map(s => s.trim().replace(/['"]/g, '')).filter(Boolean);
+                } else {
+                    // Try list
+                    const listMatch = content.match(/^dependencies:\s*\n((?:\s*-\s*.+\n?)+)/m);
+                    if (listMatch) {
+                        deps = listMatch[1].split('\n')
+                            .map(l => l.replace(/^\s*-\s*/, '').trim())
+                            .filter(Boolean);
+                    }
+                }
+
+                if (deps.length > 0) {
+                    spinner.stop();
+                    console.log(chalk.blue(`\nSkill "${skillName}" requires: ${deps.join(', ')}`));
+
+                    for (const dep of deps) {
+                        // Prevent infinite recursion if self-referencing
+                        if (dep === skillName) continue;
+
+                        if (!skillExists(dep)) {
+                            console.log(chalk.dim(`Installing dependency: ${dep}...`));
+                            // Recursive install
+                            await installSkill(dep, {
+                                ...options,
+                                force: false,
+                                noExit: true // Don't exit on dependency failure, just log
+                            });
+                        }
+                    }
+                    spinner.start(`Resuming installation of "${skillName}"...`);
+                }
+            }
+        } catch (e) {
+            // Dep check failed, but continue installing main skill
+            // console.error(e);
+        }
+
         if (options.force && existsSync(destPath)) {
             rmSync(destPath, { recursive: true, force: true });
         }
 
         cpSync(sourcePath, destPath, { recursive: true });
 
+        // Save skill metadata for future upgrades
+        try {
+            let version = '0.0.0';
+            const mdPath = join(destPath, 'SKILL.md');
+            if (existsSync(mdPath)) {
+                // We likely already imported readFileSync if inside try block, 
+                // but for safety use dynamic import or assume imported
+                const { readFileSync } = await import('fs');
+                const content = readFileSync(mdPath, 'utf-8');
+                const vMatch = content.match(/^version:\s*(.+)/m);
+                if (vMatch) version = vMatch[1].trim();
+            }
+
+            const metadata = {
+                name: skillName,
+                source: { owner, repo },
+                version,
+                installedAt: Date.now()
+            };
+            writeFileSync(join(destPath, '.antikit-skill.json'), JSON.stringify(metadata, null, 2));
+        } catch (e) {
+            // Ignore metadata write error, not critical
+        }
+
         // Cleanup temp
         rmSync(tempDir, { recursive: true, force: true });
 
@@ -87,7 +168,9 @@ export async function installSkill(skillName, options = {}) {
     } catch (error) {
         spinner.fail(`Failed to install "${skillName}"`);
         console.error(chalk.red(error.message));
+        if (options.noExit) {
+            throw error;
+        }
         process.exit(1);
     }
 }
-

package/src/commands/list.js

@@ -2,8 +2,21 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { checkbox, confirm } from '@inquirer/prompts';
 import { fetchRemoteSkills, fetchSkillInfo } from '../utils/github.js';
-import { skillExists } from '../utils/local.js';
+import { skillExists, getOrCreateSkillsDir } from '../utils/local.js';
 import { installSkill } from './install.js';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+function compareVersions(v1, v2) {
+    if (!v1 || !v2) return 0;
+    const p1 = v1.split('.').map(Number);
+    const p2 = v2.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if ((p1[i] || 0) > (p2[i] || 0)) return 1;
+        if ((p1[i] || 0) < (p2[i] || 0)) return -1;
+    }
+    return 0;
+}
 
 export async function listRemoteSkills(options) {
     const sourceName = options.source || null;
@@ -26,13 +39,32 @@ export async function listRemoteSkills(options) {
             return;
         }
 
-        // Fetch descriptions
+        const skillsDir = getOrCreateSkillsDir();
+
+        // Fetch descriptions & versions
         const infoSpinner = ora('Fetching skill info...').start();
         const skillsWithInfo = await Promise.all(
             skills.map(async (skill) => {
-                const description = await fetchSkillInfo(skill.name, skill.owner, skill.repo);
+                const info = await fetchSkillInfo(skill.name, skill.owner, skill.repo);
+                const description = info ? info.description : null;
+                const remoteVersion = info ? info.version : '0.0.0';
+
                 const installed = skillExists(skill.name);
-                return { ...skill, description, installed };
+                let updateAvailable = false;
+                let localVersion = '0.0.0';
+
+                if (installed) {
+                    try {
+                        const metaPath = join(skillsDir, skill.name, '.antikit-skill.json');
+                        if (existsSync(metaPath)) {
+                            const meta = JSON.parse(readFileSync(metaPath, 'utf8'));
+                            localVersion = meta.version || '0.0.0';
+                            updateAvailable = compareVersions(remoteVersion, localVersion) > 0;
+                        }
+                    } catch { }
+                }
+
+                return { ...skill, description, installed, updateAvailable, localVersion, remoteVersion };
             })
         );
         infoSpinner.stop();
@@ -68,11 +100,14 @@ function displaySkillsList(skills) {
     for (const [sourceName, sourceSkills] of Object.entries(bySource)) {
         console.log(chalk.magenta.bold(`\n📦 ${sourceName}`));
         for (const skill of sourceSkills) {
-            const status = skill.installed
-                ? chalk.green(' ✓')
-                : chalk.dim('  ');
+            let status = chalk.dim('  ');
+            if (skill.installed) {
+                status = skill.updateAvailable
+                    ? chalk.yellow(' ↑')
+                    : chalk.green(' ✓');
+            }
 
-            console.log(`${status} ${chalk.cyan.bold(skill.name)}`);
+            console.log(`${status} ${chalk.cyan.bold(skill.name)} ${skill.installed ? chalk.dim(`(v${skill.localVersion}${skill.updateAvailable ? ` → v${skill.remoteVersion}` : ''})`) : ''}`);
             if (skill.description) {
                 console.log(`     ${chalk.dim(skill.description)}`);
             }
@@ -85,15 +120,35 @@ function displaySkillsList(skills) {
 
 async function interactiveInstall(skills) {
     // Prepare choices for checkbox
-    const choices = skills.map(skill => ({
-        name: `${skill.installed ? chalk.green('✓') : ' '} ${chalk.cyan(skill.name)} ${chalk.dim(`[${skill.source}]`)} ${skill.description ? chalk.dim('- ' + skill.description.slice(0, 50) + '...') : ''}`,
-        value: skill,
-        disabled: skill.installed ? '(installed)' : false
-    }));
+    const choices = skills.map(skill => {
+        let label = '';
+        let disabled = false;
+
+        if (skill.installed) {
+            if (skill.updateAvailable) {
+                label = `${chalk.yellow('↑')} ${chalk.cyan(skill.name)} ${chalk.yellow(`(Update: v${skill.localVersion} → v${skill.remoteVersion})`)}`;
+            } else {
+                label = `${chalk.green('✓')} ${chalk.cyan(skill.name)} ${chalk.dim('(Installed)')}`;
+                disabled = true; // Disable if installed and no update
+            }
+        } else {
+            label = `${chalk.dim(' ')} ${chalk.cyan(skill.name)}`;
+        }
+
+        if (skill.description) {
+            label += ` ${chalk.dim('- ' + skill.description.slice(0, 40) + '...')}`;
+        }
+
+        return {
+            name: label,
+            value: skill,
+            disabled
+        };
+    });
 
     // Show checkbox selection
     const selected = await checkbox({
-        message: 'Select skills to install (Space to select, Enter to confirm):',
+        message: 'Select skills to install/update (Space to select, Enter to confirm):',
         choices,
         pageSize: 15
     });
@@ -105,21 +160,23 @@ async function interactiveInstall(skills) {
 
     // Confirm installation
     const shouldInstall = await confirm({
-        message: `Install ${selected.length} skill(s)?`,
+        message: `Install/Update ${selected.length} skill(s)?`,
         default: true
     });
 
     if (!shouldInstall) {
-        console.log(chalk.yellow('Installation cancelled.'));
+        console.log(chalk.yellow('Operation cancelled.'));
         return;
     }
 
     // Install selected skills
     console.log();
     for (const skill of selected) {
-        await installSkill(skill.name, { force: false, owner: skill.owner, repo: skill.repo });
+        // Force install if updating
+        const force = skill.installed && skill.updateAvailable;
+        await installSkill(skill.name, { force, owner: skill.owner, repo: skill.repo });
     }
 
     console.log();
-    console.log(chalk.green.bold(`✓ Installed ${selected.length} skill(s)`));
+    console.log(chalk.green.bold(`✓ Processed ${selected.length} skill(s)`));
 }

package/src/commands/upgrade.js

@@ -0,0 +1,90 @@
+import chalk from 'chalk';
+import { readdirSync, existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { getOrCreateSkillsDir } from '../utils/local.js';
+import { installSkill } from './install.js';
+import { confirm } from '@inquirer/prompts';
+
+export async function upgradeSkills(skillName, options = {}) {
+    const skillsDir = getOrCreateSkillsDir();
+
+    // 1. Upgrade specific skill
+    if (skillName) {
+        try {
+            await upgradeSingleSkill(skillsDir, skillName);
+        } catch {
+            process.exit(1);
+        }
+        return;
+    }
+
+    // 2. Upgrade all skills
+    const skills = readdirSync(skillsDir).filter(f =>
+        existsSync(join(skillsDir, f)) &&
+        !f.startsWith('.')
+    );
+
+    if (skills.length === 0) {
+        console.log(chalk.yellow('No skills installed.'));
+        return;
+    }
+
+    console.log(chalk.blue(`Found ${skills.length} installed skills.`));
+
+    let shouldProceed = options.yes;
+    if (!shouldProceed) {
+        shouldProceed = await confirm({ message: 'Upgrade all skills?', default: true });
+    }
+
+    if (!shouldProceed) return;
+
+    let successCount = 0;
+    let failCount = 0;
+
+    for (const skill of skills) {
+        try {
+            await upgradeSingleSkill(skillsDir, skill);
+            successCount++;
+        } catch {
+            failCount++;
+        }
+    }
+
+    console.log('\n────────────────────────────────────────');
+    if (failCount === 0) {
+        console.log(chalk.green(`✓ All ${successCount} skills upgraded successfully`));
+    } else {
+        console.log(chalk.yellow(`⚠ Upgraded ${successCount} skills, ${failCount} failed`));
+    }
+}
+
+async function upgradeSingleSkill(skillsDir, skillName) {
+    const skillPath = join(skillsDir, skillName);
+    const metaPath = join(skillPath, '.antikit-skill.json');
+
+    if (!existsSync(metaPath)) {
+        console.log(chalk.yellow(`⚠ Skipping "${skillName}": Missing metadata (install again to fix)`));
+        throw new Error('Missing metadata');
+    }
+
+    try {
+        const meta = JSON.parse(readFileSync(metaPath, 'utf-8'));
+        if (!meta.source || !meta.source.owner || !meta.source.repo) {
+            console.log(chalk.yellow(`⚠ Skipping "${skillName}": Invalid metadata`));
+            throw new Error('Invalid metadata');
+        }
+
+        console.log(chalk.bold.cyan(`\nUpgrading ${skillName}...`));
+
+        await installSkill(skillName, {
+            force: true,
+            owner: meta.source.owner,
+            repo: meta.source.repo,
+            noExit: true // Don't kill process on error
+        });
+
+    } catch (error) {
+        // Error already logged by installSkill or above
+        throw error;
+    }
+}

package/src/index.js

@@ -8,9 +8,11 @@ import { listLocalSkills } from './commands/local.js';
 import { installSkill } from './commands/install.js';
 import { removeSkill } from './commands/remove.js';
 import { updateCli } from './commands/update.js';
+import { upgradeSkills } from './commands/upgrade.js';
 import { listSources, addNewSource, removeExistingSource, setDefault } from './commands/source.js';
 import { checkForUpdates } from './utils/updateNotifier.js';
 
+
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 
@@ -59,6 +61,13 @@ program
   .description('Update antikit to the latest version')
   .action(updateCli);
 
+program
+  .command('upgrade [skill]')
+  .alias('ug')
+  .description('Upgrade installed skills')
+  .option('-y, --yes', 'Skip confirmation')
+  .action(upgradeSkills);
+
 // Source management commands
 const sourceCmd = program
   .command('source')

package/src/utils/github.js

@@ -95,14 +95,20 @@ export async function fetchSkillInfo(skillName, owner, repo) {
     const data = await response.json();
     const content = Buffer.from(data.content, 'base64').toString('utf-8');
 
-    // Extract description from YAML frontmatter
+    // Extract info 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;
+        const frontmatter = match[1];
+        const descMatch = frontmatter.match(/description:\s*(.+)/);
+        const versionMatch = frontmatter.match(/version:\s*(.+)/);
+
+        return {
+            description: descMatch ? descMatch[1].trim() : null,
+            version: versionMatch ? versionMatch[1].trim() : '0.0.0'
+        };
     }
 
-    return null;
+    return { description: null, version: '0.0.0' };
 }
 
 /**