antikit 1.16.0 → 1.17.0

package/README.md

@@ -238,6 +238,55 @@ 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

package/package.json

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

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/index.js

@@ -12,6 +12,8 @@ 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';
@@ -95,6 +97,20 @@ program
   .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)')