@ruaruababa/vibe-kit 1.0.0

package/dist/antigravity-skills/bin/cli.js

@@ -0,0 +1,438 @@
+#!/usr/bin/env node
+"use strict";
+const { Command } = require('commander');
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const os = require('os');
+const { listSkillIds, readSkill, tokenize, unique } = require('../lib/skill-utils');
+const { version } = require('../package.json');
+const program = new Command();
+// Resolve paths
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const SKILLS_SOURCE_DIR = path.join(PACKAGE_ROOT, 'skills');
+const CATALOG_PATH = path.join(PACKAGE_ROOT, 'catalog.json');
+const BUNDLES_PATH = path.join(PACKAGE_ROOT, 'bundles.json');
+const ALIASES_PATH = path.join(PACKAGE_ROOT, 'aliases.json');
+// Define destinations
+const GLOBAL_SKILLS_DIR = path.join(os.homedir(), '.gemini', 'antigravity', 'skills');
+const LOCAL_SKILLS_DIR = path.join(process.cwd(), '.agent', 'skills');
+program
+    .name('ag-skills')
+    .description('Manage Antigravity Skills')
+    .version(version);
+function loadJson(filePath) {
+    try {
+        if (!fs.existsSync(filePath))
+            return null;
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch (err) {
+        return null;
+    }
+}
+function loadCatalog() {
+    const catalog = loadJson(CATALOG_PATH);
+    if (catalog && Array.isArray(catalog.skills)) {
+        return catalog;
+    }
+    const skillIds = listSkillIds(SKILLS_SOURCE_DIR);
+    const skills = skillIds.map(skillId => {
+        const skill = readSkill(SKILLS_SOURCE_DIR, skillId);
+        const tags = unique([...(skill.tags || []), ...tokenize(skillId)]);
+        return {
+            id: skill.id,
+            name: skill.name,
+            description: skill.description,
+            tags,
+            category: 'general',
+        };
+    });
+    return {
+        skills,
+        total: skills.length,
+        _fallback: true,
+    };
+}
+function loadBundles() {
+    const bundles = loadJson(BUNDLES_PATH);
+    if (bundles && bundles.bundles)
+        return bundles;
+    return { bundles: {}, common: [] };
+}
+function loadAliases() {
+    const aliases = loadJson(ALIASES_PATH);
+    if (aliases && aliases.aliases)
+        return aliases.aliases;
+    return {};
+}
+function sanitizeSkillId(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    if (!normalized || !/^[a-z0-9-]+$/.test(normalized))
+        return null;
+    return normalized;
+}
+function resolveSkillId(input, aliases) {
+    const sanitized = sanitizeSkillId(input);
+    if (!sanitized)
+        return null;
+    return aliases[sanitized] || sanitized;
+}
+function resolveSkillPath(skillId) {
+    const resolved = path.resolve(SKILLS_SOURCE_DIR, skillId);
+    if (!resolved.startsWith(SKILLS_SOURCE_DIR + path.sep))
+        return null;
+    return resolved;
+}
+function truncate(value, limit) {
+    if (!value)
+        return '';
+    if (value.length <= limit)
+        return value;
+    return `${value.slice(0, limit - 3)}...`;
+}
+function scoreSkill(skill, query, queryTokens) {
+    const haystack = `${skill.id} ${skill.name || ''} ${skill.description || ''} ${(skill.tags || []).join(' ')}`.toLowerCase();
+    let score = haystack.includes(query) ? 5 : 0;
+    for (const token of queryTokens) {
+        if (skill.id.toLowerCase().includes(token))
+            score += 3;
+        if (haystack.includes(token))
+            score += 2;
+    }
+    return score;
+}
+function collectOption(value, previous) {
+    const items = Array.isArray(previous) ? previous : [];
+    const parts = String(value)
+        .split(',')
+        .map(part => part.trim())
+        .filter(Boolean);
+    return items.concat(parts);
+}
+function parseLimit(value) {
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isNaN(parsed) || parsed <= 0)
+        return 20;
+    return parsed;
+}
+function checkDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        return { exists: false, isDir: false, writable: false };
+    }
+    try {
+        const stat = fs.statSync(dirPath);
+        if (!stat.isDirectory()) {
+            return { exists: true, isDir: false, writable: false };
+        }
+        fs.accessSync(dirPath, fs.constants.W_OK);
+        return { exists: true, isDir: true, writable: true };
+    }
+    catch (err) {
+        return { exists: true, isDir: true, writable: false };
+    }
+}
+program
+    .command('list')
+    .description('List all available skills in the vault')
+    .action(() => {
+    try {
+        const skills = listSkillIds(SKILLS_SOURCE_DIR);
+        console.log(chalk.bold('\nAvailable Skills:\n'));
+        skills.forEach(skill => {
+            console.log(`- ${chalk.cyan(skill)}`);
+        });
+        console.log(chalk.green(`\nTotal: ${skills.length} skills`));
+    }
+    catch (err) {
+        console.error(chalk.red('Error listing skills:'), err.message);
+    }
+});
+program
+    .command('search <query>')
+    .description('Search skills by name, description, and tags')
+    .option('-l, --limit <number>', 'Limit results', parseLimit, 20)
+    .action((query, options) => {
+    const catalog = loadCatalog();
+    const queryText = query.toLowerCase().trim();
+    if (!queryText) {
+        console.error(chalk.red('Error: Please provide a search query.'));
+        process.exit(1);
+    }
+    if (catalog._fallback) {
+        console.warn(chalk.yellow('Warning: catalog.json not found; using fallback metadata.'));
+    }
+    const queryTokens = unique(tokenize(queryText));
+    const results = (catalog.skills || [])
+        .map(skill => ({
+        skill,
+        score: scoreSkill(skill, queryText, queryTokens),
+    }))
+        .filter(result => result.score > 0)
+        .sort((a, b) => b.score - a.score || a.skill.id.localeCompare(b.skill.id))
+        .slice(0, options.limit || 20);
+    if (!results.length) {
+        console.log(chalk.yellow('No matching skills found.'));
+        return;
+    }
+    console.log(chalk.bold(`\nSearch results (${results.length}):\n`));
+    for (const result of results) {
+        const description = truncate(result.skill.description || '', 100);
+        const tags = (result.skill.tags || []).slice(0, 6).join(', ');
+        console.log(`- ${chalk.cyan(result.skill.id)}${description ? ` - ${description}` : ''}`);
+        if (tags) {
+            console.log(`  ${chalk.gray(`tags: ${tags}`)}`);
+        }
+    }
+});
+program
+    .command('install [skillName]')
+    .description('Install a skill to your workspace or globally')
+    .option('-g, --global', 'Install to global workspace (~/.gemini/antigravity/skills)')
+    .option('-a, --all', 'Install ALL skills')
+    .option('-t, --tag <tag>', 'Install skills by tag (repeatable)', collectOption, [])
+    .option('-b, --bundle <bundle>', 'Install a curated bundle')
+    .action(async (skillName, options) => {
+    const targetDir = options.global ? GLOBAL_SKILLS_DIR : LOCAL_SKILLS_DIR;
+    const aliases = loadAliases();
+    const hasSkillName = typeof skillName === 'string' && skillName.trim().length > 0;
+    const bundleName = options.bundle ? options.bundle.toLowerCase().trim() : '';
+    const hasBundle = Boolean(bundleName);
+    const hasTags = Array.isArray(options.tag) && options.tag.length > 0;
+    const hasAll = Boolean(options.all);
+    const selectedInputs = [hasSkillName, hasAll, hasBundle, hasTags].filter(Boolean);
+    if (selectedInputs.length === 0) {
+        console.error(chalk.red('Error: Please specify a skill name or use --all/--tag/--bundle'));
+        process.exit(1);
+    }
+    if (selectedInputs.length > 1) {
+        console.error(chalk.red('Error: Choose only one of skill name, --all, --tag, or --bundle'));
+        process.exit(1);
+    }
+    try {
+        await fs.ensureDir(targetDir);
+        console.log(chalk.gray(`Target directory: ${targetDir}`));
+        let skillsToInstall = [];
+        if (hasAll) {
+            console.warn(chalk.yellow('Warning: Installing all skills increases token usage and activation noise.'));
+            skillsToInstall = listSkillIds(SKILLS_SOURCE_DIR);
+        }
+        else if (hasBundle) {
+            const bundles = loadBundles();
+            const bundle = bundles.bundles[bundleName];
+            if (!bundle) {
+                console.error(chalk.red(`Bundle '${bundleName}' not found.`));
+                const available = Object.keys(bundles.bundles).sort();
+                if (available.length) {
+                    console.log(chalk.gray(`Available bundles: ${available.join(', ')}`));
+                }
+                else {
+                    console.log(chalk.gray('Run npm run build:catalog to generate bundles.'));
+                }
+                process.exit(1);
+            }
+            if (!Array.isArray(bundle.skills) || bundle.skills.length === 0) {
+                console.error(chalk.red(`Bundle '${bundleName}' has no skills.`));
+                process.exit(1);
+            }
+            skillsToInstall = bundle.skills;
+        }
+        else if (hasTags) {
+            const catalog = loadCatalog();
+            const tagSet = new Set(options.tag.map(tag => tag.toLowerCase().trim()).filter(Boolean));
+            skillsToInstall = (catalog.skills || [])
+                .filter(skill => (skill.tags || []).some(tag => tagSet.has(String(tag).toLowerCase())))
+                .map(skill => skill.id);
+            if (!skillsToInstall.length) {
+                console.error(chalk.red(`No skills found for tags: ${Array.from(tagSet).join(', ')}`));
+                process.exit(1);
+            }
+        }
+        else if (hasSkillName) {
+            const resolved = resolveSkillId(skillName.trim(), aliases);
+            if (!resolved) {
+                console.error(chalk.red(`Invalid skill name: '${skillName}'`));
+                process.exit(1);
+            }
+            skillsToInstall = [resolved];
+        }
+        skillsToInstall = unique(skillsToInstall);
+        if (!skillsToInstall.length) {
+            console.log(chalk.yellow('No skills to install.'));
+            return;
+        }
+        for (const skill of skillsToInstall) {
+            const safeSkill = sanitizeSkillId(skill);
+            if (!safeSkill) {
+                console.error(chalk.red(`Invalid skill name: '${skill}'`));
+                continue;
+            }
+            const sourcePath = resolveSkillPath(safeSkill);
+            if (!sourcePath || !await fs.pathExists(sourcePath)) {
+                console.error(chalk.red(`Skill '${safeSkill}' not found in vault.`));
+                continue;
+            }
+            const destPath = path.join(targetDir, safeSkill);
+            await fs.copy(sourcePath, destPath, { overwrite: true });
+            console.log(`${chalk.green('✔ Installed:')} ${safeSkill}`);
+        }
+        console.log(chalk.bold.green('\nInstallation complete!'));
+        console.log('Restart your agent session to see changes.');
+    }
+    catch (err) {
+        console.error(chalk.red('Installation failed:'), err.message);
+        process.exit(1);
+    }
+});
+program
+    .command('installed')
+    .description('List skills installed in your workspace')
+    .option('-g, --global', 'List globally installed skills')
+    .action(async (options) => {
+    const targetDir = options.global ? GLOBAL_SKILLS_DIR : LOCAL_SKILLS_DIR;
+    try {
+        if (!await fs.pathExists(targetDir)) {
+            console.log(chalk.yellow(`No skills directory found at: ${targetDir}`));
+            return;
+        }
+        const installedSkills = await fs.readdir(targetDir);
+        const filteredSkills = installedSkills.filter(f => !f.startsWith('.'));
+        if (filteredSkills.length === 0) {
+            console.log(chalk.yellow('No skills installed.'));
+            return;
+        }
+        console.log(chalk.bold(`\nInstalled Skills (${options.global ? 'Global' : 'Local'}):\n`));
+        filteredSkills.forEach(skill => {
+            console.log(`- ${chalk.green(skill)}`);
+        });
+        console.log(chalk.gray(`\nLocation: ${targetDir}`));
+    }
+    catch (err) {
+        console.error(chalk.red('Error listing installed skills:'), err.message);
+    }
+});
+program
+    .command('update [skillName]')
+    .description('Update installed skills from the vault')
+    .option('-g, --global', 'Update globally installed skills')
+    .action(async (skillName, options) => {
+    const targetDir = options.global ? GLOBAL_SKILLS_DIR : LOCAL_SKILLS_DIR;
+    const aliases = loadAliases();
+    try {
+        if (!await fs.pathExists(targetDir)) {
+            console.error(chalk.red(`No installation found at: ${targetDir}`));
+            return;
+        }
+        let skillsToUpdate = [];
+        if (skillName) {
+            const resolved = resolveSkillId(skillName, aliases);
+            if (!resolved) {
+                console.error(chalk.red(`Invalid skill name: '${skillName}'`));
+                return;
+            }
+            if (await fs.pathExists(path.join(targetDir, resolved))) {
+                skillsToUpdate.push(resolved);
+            }
+            else {
+                console.error(chalk.red(`Skill '${skillName}' is not installed.`));
+                return;
+            }
+        }
+        else {
+            const installed = await fs.readdir(targetDir);
+            skillsToUpdate = installed.filter(f => !f.startsWith('.'));
+        }
+        if (skillsToUpdate.length === 0) {
+            console.log(chalk.yellow('No skills to update.'));
+            return;
+        }
+        console.log(chalk.bold(`Updating ${skillsToUpdate.length} skills...\n`));
+        for (const skill of skillsToUpdate) {
+            const safeSkill = sanitizeSkillId(skill);
+            if (!safeSkill) {
+                console.warn(chalk.yellow(`Warning: invalid skill name '${skill}'. Skipping.`));
+                continue;
+            }
+            const sourcePath = resolveSkillPath(safeSkill);
+            const destPath = path.join(targetDir, safeSkill);
+            if (!sourcePath || !await fs.pathExists(sourcePath)) {
+                console.warn(chalk.yellow(`⚠ Warning: Skill '${safeSkill}' no longer exists in vault. Skipping.`));
+                continue;
+            }
+            await fs.copy(sourcePath, destPath, { overwrite: true });
+            console.log(`${chalk.green('✔ Updated:')} ${safeSkill}`);
+        }
+        console.log(chalk.bold.green('\nUpdate complete!'));
+    }
+    catch (err) {
+        console.error(chalk.red('Update failed:'), err.message);
+        process.exit(1);
+    }
+});
+program
+    .command('doctor')
+    .description('Check install paths and catalog metadata')
+    .action(() => {
+    const localStatus = checkDir(LOCAL_SKILLS_DIR);
+    const globalStatus = checkDir(GLOBAL_SKILLS_DIR);
+    console.log(chalk.bold('\nEnvironment Check:\n'));
+    if (fs.existsSync(SKILLS_SOURCE_DIR)) {
+        const count = listSkillIds(SKILLS_SOURCE_DIR).length;
+        console.log(`Vault directory: ${SKILLS_SOURCE_DIR} (${chalk.green('OK')}, ${count} skills)`);
+    }
+    else {
+        console.log(`Vault directory: ${SKILLS_SOURCE_DIR} (${chalk.red('MISSING')})`);
+    }
+    const catalogExists = fs.existsSync(CATALOG_PATH);
+    console.log(`catalog.json: ${catalogExists ? chalk.green('OK') : chalk.red('MISSING')}`);
+    const bundlesExists = fs.existsSync(BUNDLES_PATH);
+    console.log(`bundles.json: ${bundlesExists ? chalk.green('OK') : chalk.red('MISSING')}`);
+    const aliasesExists = fs.existsSync(ALIASES_PATH);
+    console.log(`aliases.json: ${aliasesExists ? chalk.green('OK') : chalk.red('MISSING')}`);
+    console.log('');
+    console.log(`Local skills dir: ${LOCAL_SKILLS_DIR} (${localStatus.exists && localStatus.isDir ? chalk.green(localStatus.writable ? 'OK' : 'NOT WRITABLE') : chalk.red('MISSING')})`);
+    if (!localStatus.exists) {
+        console.log(chalk.gray(`Create with: mkdir -p ${LOCAL_SKILLS_DIR}`));
+    }
+    console.log(`Global skills dir: ${GLOBAL_SKILLS_DIR} (${globalStatus.exists && globalStatus.isDir ? chalk.green(globalStatus.writable ? 'OK' : 'NOT WRITABLE') : chalk.red('MISSING')})`);
+    if (!globalStatus.exists) {
+        console.log(chalk.gray(`Create with: mkdir -p ${GLOBAL_SKILLS_DIR}`));
+    }
+    if (!catalogExists || !bundlesExists || !aliasesExists) {
+        console.log('');
+        console.log(chalk.gray('Run npm run build:catalog to regenerate catalog files.'));
+    }
+});
+program
+    .command('stats')
+    .description('Show catalog statistics')
+    .action(() => {
+    const catalog = loadCatalog();
+    const bundles = loadBundles();
+    const total = catalog.total || (catalog.skills || []).length;
+    if (catalog._fallback) {
+        console.warn(chalk.yellow('Warning: catalog.json not found; stats are based on minimal metadata.'));
+    }
+    const categoryCounts = new Map();
+    for (const skill of catalog.skills || []) {
+        const category = skill.category || 'general';
+        categoryCounts.set(category, (categoryCounts.get(category) || 0) + 1);
+    }
+    const sortedCategories = Array.from(categoryCounts.entries())
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+    console.log(chalk.bold('\nCatalog Stats:\n'));
+    console.log(`Total skills: ${total}`);
+    if (catalog.generatedAt) {
+        console.log(`Catalog generated at: ${catalog.generatedAt}`);
+    }
+    console.log('');
+    console.log('Category counts:');
+    sortedCategories.forEach(([category, count]) => {
+        console.log(`- ${category}: ${count}`);
+    });
+    if (bundles.common && bundles.common.length) {
+        console.log('');
+        console.log(`Common skills (curated): ${bundles.common.join(', ')}`);
+    }
+});
+program.parse(process.argv);

package/dist/antigravity-skills/lib/skill-utils.js

@@ -0,0 +1,158 @@
+"use strict";
+const fs = require('fs');
+const path = require('path');
+const yaml = require('yaml');
+function stripQuotes(value) {
+    if (typeof value !== 'string')
+        return value;
+    if (value.length < 2)
+        return value.trim();
+    const first = value[0];
+    const last = value[value.length - 1];
+    if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+        return value.slice(1, -1).trim();
+    }
+    if (first === '"' || first === "'") {
+        return value.slice(1).trim();
+    }
+    if (last === '"' || last === "'") {
+        return value.slice(0, -1).trim();
+    }
+    return value.trim();
+}
+function parseInlineList(raw) {
+    if (typeof raw !== 'string')
+        return [];
+    const value = raw.trim();
+    if (!value.startsWith('[') || !value.endsWith(']'))
+        return [];
+    const inner = value.slice(1, -1).trim();
+    if (!inner)
+        return [];
+    return inner
+        .split(',')
+        .map(item => stripQuotes(item.trim()))
+        .filter(Boolean);
+}
+function isPlainObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value);
+}
+function parseFrontmatter(content) {
+    const sanitized = content.replace(/^\uFEFF/, '');
+    const lines = sanitized.split(/\r?\n/);
+    if (!lines.length || lines[0].trim() !== '---') {
+        return { data: {}, body: content, errors: [], hasFrontmatter: false };
+    }
+    let endIndex = -1;
+    for (let i = 1; i < lines.length; i += 1) {
+        if (lines[i].trim() === '---') {
+            endIndex = i;
+            break;
+        }
+    }
+    if (endIndex === -1) {
+        return {
+            data: {},
+            body: content,
+            errors: ['Missing closing frontmatter delimiter (---).'],
+            hasFrontmatter: true,
+        };
+    }
+    const errors = [];
+    const fmText = lines.slice(1, endIndex).join('\n');
+    let data = {};
+    try {
+        const doc = yaml.parseDocument(fmText, { prettyErrors: false });
+        if (doc.errors && doc.errors.length) {
+            errors.push(...doc.errors.map(error => error.message));
+        }
+        data = doc.toJS();
+    }
+    catch (err) {
+        errors.push(err.message);
+        data = {};
+    }
+    if (!isPlainObject(data)) {
+        errors.push('Frontmatter must be a YAML mapping/object.');
+        data = {};
+    }
+    const body = lines.slice(endIndex + 1).join('\n');
+    return { data, body, errors, hasFrontmatter: true };
+}
+function tokenize(value) {
+    if (!value)
+        return [];
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, ' ')
+        .split(' ')
+        .map(token => token.trim())
+        .filter(Boolean);
+}
+function unique(list) {
+    const seen = new Set();
+    const result = [];
+    for (const item of list) {
+        if (!item || seen.has(item))
+            continue;
+        seen.add(item);
+        result.push(item);
+    }
+    return result;
+}
+function readSkill(skillDir, skillId) {
+    const skillPath = path.join(skillDir, skillId, 'SKILL.md');
+    const content = fs.readFileSync(skillPath, 'utf8');
+    const { data } = parseFrontmatter(content);
+    const name = typeof data.name === 'string' && data.name.trim()
+        ? data.name.trim()
+        : skillId;
+    const description = typeof data.description === 'string'
+        ? data.description.trim()
+        : '';
+    let tags = [];
+    if (Array.isArray(data.tags)) {
+        tags = data.tags.map(tag => String(tag).trim());
+    }
+    else if (typeof data.tags === 'string' && data.tags.trim()) {
+        const parts = data.tags.includes(',')
+            ? data.tags.split(',')
+            : data.tags.split(/\s+/);
+        tags = parts.map(tag => tag.trim());
+    }
+    else if (isPlainObject(data.metadata) && data.metadata.tags) {
+        const rawTags = data.metadata.tags;
+        if (Array.isArray(rawTags)) {
+            tags = rawTags.map(tag => String(tag).trim());
+        }
+        else if (typeof rawTags === 'string' && rawTags.trim()) {
+            const parts = rawTags.includes(',')
+                ? rawTags.split(',')
+                : rawTags.split(/\s+/);
+            tags = parts.map(tag => tag.trim());
+        }
+    }
+    tags = tags.filter(Boolean);
+    return {
+        id: skillId,
+        name,
+        description,
+        tags,
+        path: skillPath,
+        content,
+    };
+}
+function listSkillIds(skillsDir) {
+    return fs.readdirSync(skillsDir)
+        .filter(entry => !entry.startsWith('.') && fs.statSync(path.join(skillsDir, entry)).isDirectory())
+        .sort();
+}
+module.exports = {
+    listSkillIds,
+    parseFrontmatter,
+    parseInlineList,
+    readSkill,
+    stripQuotes,
+    tokenize,
+    unique,
+};