antikit 1.3.1 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antikit",
-  "version": "1.3.1",
+  "version": "1.5.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,84 @@ 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 {
+            const metadata = {
+                name: skillName,
+                source: { owner, repo },
+                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 +156,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/update.js

@@ -0,0 +1,76 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { execSync } from 'child_process';
+import { confirm } from '@inquirer/prompts';
+
+// Since fetchLatestVersion was internal in updateNotifier.js, let's create a helper 
+// or I can duplicate the fetch logic here for simplicity, or refactor updateNotifier.js.
+// Refactoring is better practice.
+
+/**
+ * Update the CLI tool to the latest version
+ */
+export async function updateCli() {
+    const spinner = ora('Checking for updates...').start();
+
+    try {
+        // Fetch latest version from npm
+        const response = await fetch(`https://registry.npmjs.org/antikit/latest`, {
+            headers: { 'Accept': 'application/json' },
+            signal: AbortSignal.timeout(5000)
+        });
+
+        if (!response.ok) {
+            throw new Error('Failed to fetch version info from npm registry');
+        }
+
+        const data = await response.json();
+        const latestVersion = data.version;
+
+        // Import package.json to get current version
+        // Using dynamic import to avoid requiring createRequire in this module if possible, 
+        // but for consistency with index.js style
+        const { createRequire } = await import('module');
+        const require = createRequire(import.meta.url);
+        const pkg = require('../../package.json');
+        const currentVersion = pkg.version;
+
+        spinner.stop();
+
+        if (latestVersion === currentVersion) {
+            console.log(chalk.green(`\n✓ You are already on the latest version (${currentVersion})`));
+            return;
+        }
+
+        console.log(chalk.bold(`\nUpdate available: ${chalk.dim(currentVersion)} → ${chalk.green(latestVersion)}`));
+
+        const shouldUpdate = await confirm({
+            message: 'Do you want to update now?',
+            default: true
+        });
+
+        if (!shouldUpdate) {
+            console.log(chalk.yellow('Update cancelled.'));
+            return;
+        }
+
+        const updateSpinner = ora('Updating antikit...').start();
+
+        try {
+            execSync('npm install -g antikit@latest', { stdio: 'pipe' });
+            updateSpinner.succeed(chalk.green(`Updated to version ${latestVersion}`));
+            console.log(chalk.dim('\nYou may need to restart your terminal for changes to take effect.'));
+        } catch (err) {
+            updateSpinner.fail('Update failed');
+            console.log(chalk.red('Please try running: npm install -g antikit@latest'));
+            // Check for permission error
+            if (err.message.includes('EACCES')) {
+                console.log(chalk.yellow('Note: You might need to run with sudo'));
+            }
+        }
+
+    } catch (error) {
+        spinner.fail('Failed to check for updates');
+        console.error(chalk.red(error.message));
+    }
+}

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

@@ -7,9 +7,12 @@ import { listRemoteSkills } from './commands/list.js';
 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');
 
@@ -52,6 +55,19 @@ program
   .description('Remove an installed skill')
   .action(removeSkill);
 
+program
+  .command('update')
+  .alias('up')
+  .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')