antikit 1.15.0 → 1.17.0

package/README.md

@@ -204,6 +204,91 @@ antikit config set-token <new_token>
 antikit config remove-token
 ```
 
+### 📊 Statistics & Analytics
+
+View insights about your installed skills.
+
+```bash
+# Show comprehensive statistics
+antikit stats
+```
+
+**What you'll see:**
+- 📈 **Overview** - Total skills, sources, metadata coverage
+- 📦 **Source Distribution** - Skills grouped by source with percentages
+- 🔢 **Version Stats** - Version tracking information
+- 🌟 **Top Skills** - Recently installed or most used skills
+
+**Example Output:**
+```
+📊 Antikit Statistics
+
+Metric                        Value
+────────────────────────────────────
+Total Skills Installed        12
+Total Sources Configured      3
+Skills with Metadata          10
+
+📦 Skills by Source:
+
+Source                  Skills    Percentage
+───────────────────────────────────────────
+antiskills             8         66.7% ████████████████
+claudekit              3         25.0% █████
+local                  1         8.3%  ██
+```
+
+
+---
+
+### 💾 Backup & Restore
+
+Export and import your skills configuration for easy migration between machines or disaster recovery.
+
+**Create Backup**
+
+```bash
+# Create backup with auto-generated filename
+antikit backup
+# Creates: antikit-backup-2026-01-15.json
+
+# Specify custom output file
+antikit backup my-setup.json
+
+# Force backup even if no skills installed
+antikit backup --force
+```
+
+**Restore from Backup**
+
+```bash
+# Restore with confirmation prompt
+antikit restore antikit-backup-2026-01-15.json
+
+# Auto-confirm (no prompts)
+antikit restore my-setup.json --yes
+
+# Force reinstall existing skills
+antikit restore my-setup.json --force
+
+# Skip restoring sources (only install skills)
+antikit restore my-setup.json --skip-sources
+```
+
+**Backup File Contents:**
+- 📦 List of installed skills with versions
+- 🔗 Source configurations
+- 📅 Backup timestamp and metadata
+- 🔒 Config (tokens are masked for security)
+
+**Use Cases:**
+- 🖥️ **Team Onboarding** - Share skill setup with team members
+- 🔄 **Machine Migration** - Move setup to new computer
+- 💾 **Disaster Recovery** - Restore after accidental removal
+- 📸 **Snapshots** - Backup before major changes
+
+---
+
 ### 🔄 Tool Maintenance
 
 **Update CLI**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antikit",
-  "version": "1.15.0",
+  "version": "1.17.0",
   "description": "CLI tool to manage AI agent skills from Anti Gravity skills repository",
   "type": "module",
   "main": "src/index.js",
@@ -12,6 +12,7 @@
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
     "release": "commit-and-tag-version",
+    "release:push": "./scripts/release.sh",
     "prepare": "husky",
     "format": "prettier --write ."
   },

package/src/commands/backup.js

@@ -0,0 +1,118 @@
+import chalk from 'chalk';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+import { confirm } from '@inquirer/prompts';
+import { getLocalSkills, findLocalSkillsDir } from '../utils/local.js';
+import { getSources, loadConfig } from '../utils/configManager.js';
+import { METADATA_FILE } from '../utils/constants.js';
+import { existsSync, readFileSync } from 'fs';
+
+export async function backupSkills(outputPath, options = {}) {
+    const skillsDir = findLocalSkillsDir();
+
+    if (!skillsDir) {
+        console.log(chalk.yellow('No .agent/skills directory found in current path.'));
+        console.log(chalk.dim('Nothing to backup.'));
+        return;
+    }
+
+    const skills = getLocalSkills();
+
+    if (skills.length === 0 && !options.force) {
+        console.log(chalk.yellow('No skills installed to backup.'));
+        const shouldContinue = await confirm({
+            message: 'Continue with empty backup?',
+            default: false
+        });
+        if (!shouldContinue) {
+            console.log(chalk.yellow('Backup cancelled.'));
+            return;
+        }
+    }
+
+    console.log(chalk.bold.cyan('\n💾 Creating backup...\n'));
+
+    // Prepare backup data
+    const backupData = {
+        version: getPackageVersion(),
+        backupDate: new Date().toISOString(),
+        skillsDirectory: skillsDir,
+        totalSkills: skills.length,
+        skills: [],
+        sources: getSources(),
+        config: getConfigForBackup()
+    };
+
+    // Collect skill metadata
+    for (const skill of skills) {
+        const metaPath = join(skill.path, METADATA_FILE);
+        const skillData = {
+            name: skill.name,
+            description: skill.description || null
+        };
+
+        if (existsSync(metaPath)) {
+            try {
+                const meta = JSON.parse(readFileSync(metaPath, 'utf-8'));
+                skillData.version = meta.version || null;
+                skillData.source = meta.source || null;
+                skillData.sourceName = meta.sourceName || null;
+                skillData.installedDate = meta.installedAt || null;
+            } catch (error) {
+                console.log(chalk.dim(`⚠️  Could not read metadata for ${skill.name}`));
+            }
+        }
+
+        backupData.skills.push(skillData);
+    }
+
+    // Determine output path
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0];
+    const defaultFilename = `antikit-backup-${timestamp}.json`;
+    const finalPath = outputPath || defaultFilename;
+
+    // Write backup file
+    try {
+        writeFileSync(finalPath, JSON.stringify(backupData, null, 2));
+
+        console.log(chalk.green('✓ Backup created successfully!\n'));
+        console.log(chalk.bold('Backup Summary:'));
+        console.log(chalk.dim('─'.repeat(50)));
+        console.log(`${chalk.cyan('File:')} ${finalPath}`);
+        console.log(`${chalk.cyan('Skills:')} ${backupData.totalSkills}`);
+        console.log(`${chalk.cyan('Sources:')} ${backupData.sources.length}`);
+        console.log(`${chalk.cyan('Date:')} ${new Date(backupData.backupDate).toLocaleString()}`);
+        console.log(chalk.dim('─'.repeat(50)));
+        console.log();
+        console.log(chalk.dim(`To restore: ${chalk.white(`antikit restore ${finalPath}`)}`));
+        console.log();
+
+    } catch (error) {
+        console.error(chalk.red(`✗ Failed to create backup: ${error.message}`));
+        process.exit(1);
+    }
+}
+
+function getPackageVersion() {
+    try {
+        const pkgPath = join(process.cwd(), 'package.json');
+        if (existsSync(pkgPath)) {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+            return pkg.version || 'unknown';
+        }
+    } catch { }
+    return 'unknown';
+}
+
+function getConfigForBackup() {
+    try {
+        const config = loadConfig();
+        // Mask sensitive data
+        return {
+            githubToken: config.githubToken ? '***MASKED***' : null,
+            sourcesCount: config.sources?.length || 0
+        };
+    } catch {
+        return null;
+    }
+}

package/src/commands/restore.js

@@ -0,0 +1,196 @@
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'fs';
+import { confirm } from '@inquirer/prompts';
+import Table from 'cli-table3';
+import { installSkill } from './install.js';
+import { addSource } from '../utils/configManager.js';
+import { skillExists } from '../utils/local.js';
+
+export async function restoreSkills(backupPath, options = {}) {
+    if (!backupPath) {
+        console.log(chalk.red('Please specify a backup file to restore.'));
+        console.log(chalk.dim('Usage: antikit restore <backup-file.json>'));
+        process.exit(1);
+    }
+
+    if (!existsSync(backupPath)) {
+        console.log(chalk.red(`Backup file not found: ${backupPath}`));
+        process.exit(1);
+    }
+
+    // Load backup file
+    let backupData;
+    try {
+        const content = readFileSync(backupPath, 'utf-8');
+        backupData = JSON.parse(content);
+    } catch (error) {
+        console.log(chalk.red(`Invalid backup file: ${error.message}`));
+        process.exit(1);
+    }
+
+    // Validate backup structure
+    if (!backupData.skills || !Array.isArray(backupData.skills)) {
+        console.log(chalk.red('Invalid backup format: missing skills array'));
+        process.exit(1);
+    }
+
+    console.log(chalk.bold.cyan('\n📦 Restore from Backup\n'));
+    console.log(chalk.dim('Backup Information:'));
+    console.log(chalk.dim('─'.repeat(50)));
+    console.log(`${chalk.cyan('Date:')} ${new Date(backupData.backupDate).toLocaleString()}`);
+    console.log(`${chalk.cyan('Skills:')} ${backupData.totalSkills || backupData.skills.length}`);
+    console.log(`${chalk.cyan('Sources:')} ${backupData.sources?.length || 0}`);
+    console.log(chalk.dim('─'.repeat(50)));
+    console.log();
+
+    // Show skills to be restored
+    displaySkillsPreview(backupData.skills);
+
+    // Confirm restoration
+    if (!options.yes) {
+        const shouldRestore = await confirm({
+            message: `Restore ${backupData.skills.length} skill(s)?`,
+            default: true
+        });
+
+        if (!shouldRestore) {
+            console.log(chalk.yellow('Restore cancelled.'));
+            return;
+        }
+    }
+
+    console.log();
+
+    // Restore sources first (if any)
+    if (backupData.sources && backupData.sources.length > 0 && !options.skipSources) {
+        await restoreSources(backupData.sources);
+    }
+
+    // Restore skills
+    await restoreSkillsList(backupData.skills, options);
+
+    console.log();
+    console.log(chalk.green.bold('✓ Restore completed!'));
+    console.log();
+}
+
+function displaySkillsPreview(skills) {
+    if (skills.length === 0) {
+        console.log(chalk.yellow('No skills in backup.'));
+        return;
+    }
+
+    console.log(chalk.bold('Skills to restore:\n'));
+
+    const table = new Table({
+        head: [chalk.cyan('Skill'), chalk.cyan('Version'), chalk.cyan('Source'), chalk.cyan('Status')],
+        colWidths: [25, 12, 25, 15],
+        wordWrap: true,
+        style: { head: [], border: [] }
+    });
+
+    const previewCount = Math.min(10, skills.length);
+
+    for (let i = 0; i < previewCount; i++) {
+        const skill = skills[i];
+        const status = skillExists(skill.name) ? chalk.yellow('Update') : chalk.green('New');
+
+        table.push([
+            chalk.bold(skill.name),
+            skill.version || chalk.dim('N/A'),
+            skill.sourceName || chalk.dim('local'),
+            status
+        ]);
+    }
+
+    console.log(table.toString());
+
+    if (skills.length > previewCount) {
+        console.log(chalk.dim(`\n... and ${skills.length - previewCount} more skills`));
+    }
+
+    console.log();
+}
+
+async function restoreSources(sources) {
+    console.log(chalk.bold.cyan('📡 Restoring sources...\n'));
+
+    let addedCount = 0;
+    let skippedCount = 0;
+
+    for (const source of sources) {
+        // Skip default source (should already exist)
+        if (source.default) {
+            skippedCount++;
+            continue;
+        }
+
+        try {
+            addSource(
+                source.name,
+                source.owner,
+                source.repo,
+                source.branch || 'main',
+                source.path || null
+            );
+            console.log(chalk.green(`✓ Added source: ${source.name}`));
+            addedCount++;
+        } catch (error) {
+            // Source might already exist
+            if (error.message.includes('already exists')) {
+                console.log(chalk.dim(`⊙ Source already exists: ${source.name}`));
+                skippedCount++;
+            } else {
+                console.log(chalk.yellow(`⚠ Failed to add source ${source.name}: ${error.message}`));
+            }
+        }
+    }
+
+    console.log(chalk.dim(`\nSources: ${addedCount} added, ${skippedCount} skipped\n`));
+}
+
+async function restoreSkillsList(skills, options) {
+    console.log(chalk.bold.cyan('🔧 Installing skills...\n'));
+
+    let successCount = 0;
+    let skipCount = 0;
+    let failCount = 0;
+
+    for (const skill of skills) {
+        // Skip if already installed and not forcing
+        if (skillExists(skill.name) && !options.force) {
+            console.log(chalk.dim(`⊙ Skipping ${skill.name} (already installed)`));
+            skipCount++;
+            continue;
+        }
+
+        // Prepare install options
+        const installOptions = {
+            force: options.force || false,
+            noExit: true
+        };
+
+        // Add source info if available
+        if (skill.source && skill.source.owner && skill.source.repo) {
+            installOptions.owner = skill.source.owner;
+            installOptions.repo = skill.source.repo;
+            installOptions.path = skill.source.path || null;
+        }
+
+        try {
+            await installSkill(skill.name, installOptions);
+            successCount++;
+        } catch (error) {
+            console.log(chalk.red(`✗ Failed to install ${skill.name}: ${error.message}`));
+            failCount++;
+        }
+    }
+
+    // Summary
+    console.log('\n' + chalk.dim('─'.repeat(50)));
+    console.log(chalk.bold('Restore Summary:'));
+    console.log(`${chalk.green('Installed:')} ${successCount}`);
+    if (skipCount > 0) console.log(`${chalk.dim('Skipped:')} ${skipCount}`);
+    if (failCount > 0) console.log(`${chalk.red('Failed:')} ${failCount}`);
+    console.log(chalk.dim('─'.repeat(50)));
+}

package/src/commands/stats.js

@@ -0,0 +1,196 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { getLocalSkills, findLocalSkillsDir } from '../utils/local.js';
+import { getSources } from '../utils/configManager.js';
+import { METADATA_FILE } from '../utils/constants.js';
+
+export async function showStats() {
+    const skillsDir = findLocalSkillsDir();
+
+    if (!skillsDir) {
+        console.log(chalk.yellow('No .agent/skills directory found in current path.'));
+        console.log(chalk.dim('Run this command from a project with .agent/skills folder.'));
+        return;
+    }
+
+    const skills = getLocalSkills();
+    const sources = getSources();
+
+    console.log(chalk.bold.cyan('\n📊 Antikit Statistics\n'));
+    console.log(chalk.dim(`Skills directory: ${skillsDir}\n`));
+
+    // 1. Overview Stats
+    displayOverview(skills, sources);
+
+    if (skills.length > 0) {
+        // 2. Source Distribution
+        displaySourceDistribution(skills);
+
+        // 3. Version Stats
+        displayVersionStats(skills);
+
+        // 4. Top Skills (by size or complexity)
+        displayTopSkills(skills);
+    }
+
+    console.log();
+}
+
+function displayOverview(skills, sources) {
+    const overview = new Table({
+        head: [chalk.cyan('Metric'), chalk.cyan('Value')],
+        colWidths: [30, 20],
+        style: { head: [], border: [] }
+    });
+
+    overview.push(
+        [chalk.bold('Total Skills Installed'), chalk.green.bold(skills.length.toString())],
+        [chalk.bold('Total Sources Configured'), chalk.blue(sources.length.toString())],
+        [
+            chalk.bold('Skills with Metadata'),
+            chalk.yellow(
+                skills.filter(s => {
+                    const metaPath = join(s.path, METADATA_FILE);
+                    return existsSync(metaPath);
+                }).length.toString()
+            )
+        ]
+    );
+
+    console.log(overview.toString());
+    console.log();
+}
+
+function displaySourceDistribution(skills) {
+    const sourceMap = new Map();
+
+    skills.forEach(skill => {
+        const metaPath = join(skill.path, METADATA_FILE);
+        let sourceName = 'local';
+
+        if (existsSync(metaPath)) {
+            try {
+                const meta = JSON.parse(readFileSync(metaPath, 'utf-8'));
+                if (meta.source && meta.source.owner && meta.source.repo) {
+                    // Use source name if available, otherwise owner/repo
+                    sourceName = meta.sourceName || `${meta.source.owner}/${meta.source.repo}`;
+                }
+            } catch { }
+        }
+
+        sourceMap.set(sourceName, (sourceMap.get(sourceName) || 0) + 1);
+    });
+
+    // Sort by count descending
+    const sortedSources = Array.from(sourceMap.entries()).sort((a, b) => b[1] - a[1]);
+
+    console.log(chalk.bold.cyan('📦 Skills by Source:\n'));
+
+    const sourceTable = new Table({
+        head: [chalk.cyan('Source'), chalk.cyan('Skills'), chalk.cyan('Percentage')],
+        colWidths: [35, 12, 15],
+        style: { head: [], border: [] }
+    });
+
+    const total = skills.length;
+    sortedSources.forEach(([source, count]) => {
+        const percentage = ((count / total) * 100).toFixed(1);
+        const bar = '█'.repeat(Math.ceil((count / total) * 20));
+
+        sourceTable.push([
+            chalk.magenta(source),
+            chalk.green(count.toString()),
+            chalk.yellow(`${percentage}%`) + ' ' + chalk.dim(bar)
+        ]);
+    });
+
+    console.log(sourceTable.toString());
+    console.log();
+}
+
+function displayVersionStats(skills) {
+    let withVersion = 0;
+    let withoutVersion = 0;
+    const versions = new Map();
+
+    skills.forEach(skill => {
+        const metaPath = join(skill.path, METADATA_FILE);
+
+        if (existsSync(metaPath)) {
+            try {
+                const meta = JSON.parse(readFileSync(metaPath, 'utf-8'));
+                if (meta.version) {
+                    withVersion++;
+                    // Track version patterns (major.minor.patch)
+                    const major = meta.version.split('.')[0];
+                    versions.set(major, (versions.get(major) || 0) + 1);
+                } else {
+                    withoutVersion++;
+                }
+            } catch {
+                withoutVersion++;
+            }
+        } else {
+            withoutVersion++;
+        }
+    });
+
+    console.log(chalk.bold.cyan('🔢 Version Information:\n'));
+
+    const versionTable = new Table({
+        head: [chalk.cyan('Status'), chalk.cyan('Count')],
+        colWidths: [35, 15],
+        style: { head: [], border: [] }
+    });
+
+    versionTable.push(
+        ['Skills with version info', chalk.green(withVersion.toString())],
+        ['Skills without version info', chalk.dim(withoutVersion.toString())]
+    );
+
+    console.log(versionTable.toString());
+    console.log();
+}
+
+function displayTopSkills(skills) {
+    // Show skills sorted by name with their basic info
+    const topCount = Math.min(5, skills.length);
+
+    console.log(chalk.bold.cyan(`🌟 Installed Skills (showing ${topCount} of ${skills.length}):\n`));
+
+    const topTable = new Table({
+        head: [chalk.cyan('Skill Name'), chalk.cyan('Version'), chalk.cyan('Source')],
+        colWidths: [30, 15, 25],
+        wordWrap: true,
+        style: { head: [], border: [] }
+    });
+
+    // Sort alphabetically and take top N
+    const sortedSkills = [...skills].sort((a, b) => a.name.localeCompare(b.name)).slice(0, topCount);
+
+    sortedSkills.forEach(skill => {
+        const metaPath = join(skill.path, METADATA_FILE);
+        let version = chalk.dim('local');
+        let source = chalk.dim('local');
+
+        if (existsSync(metaPath)) {
+            try {
+                const meta = JSON.parse(readFileSync(metaPath, 'utf-8'));
+                if (meta.version) version = chalk.yellow(meta.version);
+                if (meta.source && meta.source.owner && meta.source.repo) {
+                    source = chalk.magenta(meta.sourceName || `${meta.source.owner}/${meta.source.repo}`);
+                }
+            } catch { }
+        }
+
+        topTable.push([chalk.bold.cyan(skill.name), version, source]);
+    });
+
+    console.log(topTable.toString());
+
+    if (skills.length > topCount) {
+        console.log(chalk.dim(`\n... and ${skills.length - topCount} more. Use 'antikit local' to see all.`));
+    }
+}

package/src/index.js

@@ -11,6 +11,9 @@ import { showSkillInfo } from './commands/info.js';
 import { validateSkill } from './commands/validate.js';
 import { updateCli } from './commands/update.js';
 import { upgradeSkills } from './commands/upgrade.js';
+import { showStats } from './commands/stats.js';
+import { backupSkills } from './commands/backup.js';
+import { restoreSkills } from './commands/restore.js';
 import { listSources, addNewSource, removeExistingSource, setDefault } from './commands/source.js';
 import { listConfig, setGitHubToken, removeGitHubToken } from './commands/config.js';
 import { checkForUpdates } from './utils/updateNotifier.js';
@@ -89,6 +92,25 @@ program
   .option('-y, --yes', 'Skip confirmation')
   .action(upgradeSkills);
 
+program
+  .command('stats')
+  .description('Show statistics about installed skills')
+  .action(showStats);
+
+program
+  .command('backup [output]')
+  .description('Backup installed skills configuration')
+  .option('-f, --force', 'Create backup even if no skills installed')
+  .action(backupSkills);
+
+program
+  .command('restore <backup-file>')
+  .description('Restore skills from backup file')
+  .option('-y, --yes', 'Skip confirmation')
+  .option('-f, --force', 'Force reinstall existing skills')
+  .option('--skip-sources', 'Skip restoring sources')
+  .action(restoreSkills);
+
 program
   .command('completion')
   .description('Setup autocomplete for your shell (zsh/bash)')