agent-skills-standard 1.0.4

package/dist/commands/init.d.ts

@@ -0,0 +1,3 @@
+export declare class InitCommand {
+    run(): Promise<void>;
+}

package/dist/commands/init.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitCommand = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const path_1 = __importDefault(require("path"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const constants_1 = require("../constants");
+class InitCommand {
+    async run() {
+        const configPath = path_1.default.join(process.cwd(), '.skillsrc');
+        // Project detection
+        const detectionResults = {};
+        for (const framework of constants_1.SUPPORTED_FRAMEWORKS) {
+            let detected = false;
+            for (const file of framework.detectionFiles) {
+                if (await fs_extra_1.default.pathExists(file)) {
+                    detected = true;
+                    break;
+                }
+            }
+            detectionResults[framework.id] = detected;
+        }
+        // Agent detection
+        const agentDetection = {};
+        for (const agent of constants_1.SUPPORTED_AGENTS) {
+            let detected = false;
+            for (const file of agent.detectionFiles) {
+                if (await fs_extra_1.default.pathExists(file)) {
+                    detected = true;
+                    break;
+                }
+            }
+            agentDetection[agent.id] = detected;
+        }
+        const anyAgentDetected = Object.values(agentDetection).some((d) => d);
+        // Helper to determine if an agent should be pre-selected
+        const shouldCheck = (id) => anyAgentDetected ? agentDetection[id] : true;
+        // Supported categories are now determined by the registry contents if possible
+        // Default to a sane list if registry is unreachable
+        let supportedCategories = ['flutter', 'dart'];
+        let metadata = {};
+        const treeUrl = 'https://api.github.com/repos/HoangNguyen0403/agent-skills-standard/git/trees/main?recursive=1';
+        const metadataUrl = 'https://raw.githubusercontent.com/HoangNguyen0403/agent-skills-standard/main/skills/metadata.json';
+        try {
+            const [treeRes, metadataRes] = await Promise.all([
+                (0, node_fetch_1.default)(treeUrl, {
+                    headers: { Accept: 'application/vnd.github.v3+json' },
+                }),
+                (0, node_fetch_1.default)(metadataUrl),
+            ]);
+            if (metadataRes.ok) {
+                metadata = (await metadataRes.json());
+            }
+            if (treeRes.ok) {
+                const treeData = (await treeRes.json());
+                const allFiles = treeData.tree || [];
+                // Extract top-level folders in skills/
+                const categories = new Set();
+                allFiles.forEach((f) => {
+                    if (f.path.startsWith('skills/') && f.type === 'tree') {
+                        const parts = f.path.split('/');
+                        if (parts.length === 2) {
+                            categories.add(parts[1]);
+                        }
+                    }
+                });
+                if (categories.size > 0) {
+                    supportedCategories = Array.from(categories);
+                }
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            console.error(picocolors_1.default.red(`❌ Failed to fetch registry metadata or tree: ${msg}`));
+        }
+        const choices = constants_1.SUPPORTED_FRAMEWORKS.map((f) => {
+            const isSupported = supportedCategories.includes(f.id);
+            return {
+                name: isSupported ? f.name : `${f.name} (Coming Soon)`,
+                value: f.id,
+            };
+        });
+        if (await fs_extra_1.default.pathExists(configPath)) {
+            const { overwrite } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'overwrite',
+                    message: '.skillsrc already exists. Do you want to overwrite it?',
+                    default: false,
+                },
+            ]);
+            if (!overwrite) {
+                console.log(picocolors_1.default.yellow('Aborted.'));
+                return;
+            }
+        }
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'framework',
+                message: 'Select Framework:',
+                choices: choices,
+                default: constants_1.SUPPORTED_FRAMEWORKS.find((f) => detectionResults[f.id])?.id ||
+                    'flutter',
+            },
+            {
+                type: 'checkbox',
+                name: 'agents',
+                message: 'Select AI Agents you use:',
+                choices: constants_1.SUPPORTED_AGENTS.map((a) => ({
+                    name: `${a.name} (${a.path}/)`,
+                    value: a.id,
+                    checked: shouldCheck(a.id),
+                })),
+            },
+            {
+                type: 'input',
+                name: 'registry',
+                message: 'Skills Registry URL:',
+                default: 'https://github.com/HoangNguyen0403/agent-skills-standard',
+            },
+        ]);
+        const frameworkId = answers.framework;
+        const selectedFramework = constants_1.SUPPORTED_FRAMEWORKS.find((f) => f.id === frameworkId);
+        const isSupported = supportedCategories.includes(frameworkId);
+        if (!isSupported) {
+            console.log(picocolors_1.default.yellow(`\nNotice: Skills for ${frameworkId} are not yet strictly defined and will be added soon.`));
+            console.log(picocolors_1.default.gray('The CLI will still generate rule files with global standards.\n'));
+        }
+        const neededSkills = new Set();
+        neededSkills.add(frameworkId);
+        if (selectedFramework) {
+            selectedFramework.languages.forEach((l) => neededSkills.add(l));
+        }
+        const config = {
+            registry: answers.registry,
+            agents: answers.agents,
+            skills: {},
+            custom_overrides: [],
+        };
+        // Initialize all potential skills from the registry folders we know
+        // This will be expanded as more frameworks are added to the repo
+        const allKnownCategories = [
+            ...constants_1.SUPPORTED_FRAMEWORKS.map((f) => f.id),
+            ...constants_1.SUPPORTED_FRAMEWORKS.flatMap((f) => f.languages),
+        ];
+        for (const skill of [...new Set(allKnownCategories)]) {
+            if (neededSkills.has(skill)) {
+                const skillMeta = metadata.categories?.[skill];
+                let refStr;
+                if (skillMeta?.version && skillMeta?.tag_prefix) {
+                    refStr = `${skillMeta.tag_prefix}${skillMeta.version}`;
+                }
+                config.skills[skill] = {
+                    enabled: true,
+                    ref: refStr,
+                };
+            }
+        }
+        await fs_extra_1.default.writeFile(configPath, js_yaml_1.default.dump(config));
+        console.log(picocolors_1.default.green('\n✅ Initialized .skillsrc with your preferences!'));
+        console.log(picocolors_1.default.gray(`   Selected framework: ${frameworkId}`));
+        console.log(picocolors_1.default.gray(`   Auto-enabled languages: ${Array.from(neededSkills)
+            .filter((s) => s !== frameworkId)
+            .join(', ') || 'none'}`));
+        console.log(picocolors_1.default.cyan('\nNext step: Run `agent-skills sync` to generate rule files.'));
+    }
+}
+exports.InitCommand = InitCommand;

package/dist/commands/sync.d.ts

@@ -0,0 +1,5 @@
+export declare class SyncCommand {
+    run(): Promise<void>;
+    private assembleFromRemote;
+    private writeToTargets;
+}

package/dist/commands/sync.js

@@ -0,0 +1,153 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncCommand = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const path_1 = __importDefault(require("path"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const constants_1 = require("../constants");
+class SyncCommand {
+    async run() {
+        const configPath = path_1.default.join(process.cwd(), '.skillsrc');
+        if (!(await fs_extra_1.default.pathExists(configPath))) {
+            console.log(picocolors_1.default.red('❌ Error: .skillsrc not found in current directory.'));
+            console.log(picocolors_1.default.yellow('Run `agent-skills init` first.'));
+            return;
+        }
+        try {
+            const fileContent = await fs_extra_1.default.readFile(configPath, 'utf8');
+            const config = js_yaml_1.default.load(fileContent);
+            console.log(picocolors_1.default.cyan(`🚀 Syncing skills from ${config.registry}...`));
+            const enabledCategories = Object.entries(config.skills)
+                .filter(([, value]) => value.enabled)
+                .map(([key]) => key);
+            const skills = await this.assembleFromRemote(enabledCategories, config);
+            await this.writeToTargets(skills, config);
+            console.log(picocolors_1.default.green('✅ All skills synced successfully!'));
+        }
+        catch (error) {
+            console.error(picocolors_1.default.red('❌ Failed to sync skills:'), error);
+        }
+    }
+    async assembleFromRemote(categories, config) {
+        const collected = [];
+        // Parse owner and repo from registry URL
+        // Expected: https://github.com/owner/repo
+        const githubMatch = config.registry.match(/github\.com\/([^/]+)\/([^/]+)/i);
+        if (!githubMatch) {
+            console.log(picocolors_1.default.red('Error: Only GitHub registries are supported for auto-discovery.'));
+            return [];
+        }
+        const [owner, repo] = githubMatch.slice(1);
+        // We iterate categories individually to handle versioning (different refs)
+        for (const category of categories) {
+            const categoryConfig = config.skills[category];
+            const ref = categoryConfig.ref || 'main';
+            const rawBaseUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/skills/`;
+            const treeUrl = `https://api.github.com/repos/${owner}/${repo}/git/trees/${ref}?recursive=1`;
+            try {
+                console.log(picocolors_1.default.gray(`  - Discovering ${category} skills via GitHub API (${ref})...`));
+                const treeRes = await (0, node_fetch_1.default)(treeUrl, {
+                    headers: { Accept: 'application/vnd.github.v3+json' },
+                });
+                if (!treeRes.ok) {
+                    console.log(picocolors_1.default.red(`    ❌ Failed to fetch ${category}@${ref} (Status: ${treeRes.status}). Skipping.`));
+                    continue;
+                }
+                const treeData = (await treeRes.json());
+                const allFiles = treeData.tree || [];
+                // Find all skill folder names first
+                const skillFolders = Array.from(new Set(allFiles
+                    .filter((f) => f.path.startsWith(`skills/${category}/`))
+                    .map((f) => {
+                    const parts = f.path.split('/');
+                    return parts[2]; // skills/category/SKILL_NAME/file.md
+                })
+                    .filter(Boolean)));
+                for (const skillFolderName of skillFolders) {
+                    if (categoryConfig.include &&
+                        !categoryConfig.include.includes(skillFolderName))
+                        continue;
+                    if (categoryConfig.exclude &&
+                        categoryConfig.exclude.includes(skillFolderName))
+                        continue;
+                    const skillFiles = [];
+                    // Find all files belonging to this specific skill
+                    const skillSourceFiles = allFiles.filter((f) => f.path.startsWith(`skills/${category}/${skillFolderName}/`));
+                    for (const fileItem of skillSourceFiles) {
+                        // Get relative path within the skill folder (e.g., "SKILL.md" or "references/REFERENCE.md")
+                        const relativePath = fileItem.path.replace(`skills/${category}/${skillFolderName}/`, '');
+                        // Only sync supported files and directories based on standard
+                        const isSupported = relativePath === 'SKILL.md' ||
+                            relativePath.startsWith('references/') ||
+                            relativePath.startsWith('scripts/') ||
+                            relativePath.startsWith('assets/');
+                        if (isSupported && fileItem.type === 'blob') {
+                            const fileUrl = `${rawBaseUrl}${category}/${skillFolderName}/${relativePath}`;
+                            const fileRes = await (0, node_fetch_1.default)(fileUrl);
+                            if (fileRes.ok) {
+                                const content = await fileRes.text();
+                                skillFiles.push({ name: relativePath, content });
+                            }
+                        }
+                    }
+                    if (skillFiles.length > 0) {
+                        collected.push({
+                            category,
+                            skill: skillFolderName,
+                            files: skillFiles,
+                        });
+                        console.log(picocolors_1.default.gray(`    + Fetched ${category}/${skillFolderName} (${skillFiles.length} files)`));
+                    }
+                }
+            }
+            catch (error) {
+                console.log(picocolors_1.default.red(`Error: Failed to fetch remote skills for ${category}. ${error}`));
+            }
+        } // End category loop
+        return collected;
+    }
+    async writeToTargets(skills, config) {
+        const agents = config.agents || constants_1.SUPPORTED_AGENTS.map((a) => a.id);
+        const overrides = config.custom_overrides || [];
+        for (const agentId of agents) {
+            const agentDef = constants_1.SUPPORTED_AGENTS.find((a) => a.id === agentId);
+            if (!agentDef)
+                continue;
+            const basePath = agentDef.path;
+            if (basePath) {
+                // We do NOT use emptyDir here because we want to preserve user's own custom skills
+                await fs_extra_1.default.ensureDir(basePath);
+                for (const skill of skills) {
+                    const skillFolderName = `${skill.category}-${skill.skill}`;
+                    const skillPath = path_1.default.join(basePath, skillFolderName);
+                    await fs_extra_1.default.ensureDir(skillPath);
+                    for (const fileItem of skill.files) {
+                        const targetFilePath = path_1.default.join(skillPath, fileItem.name);
+                        // Check if this specific file is in custom_overrides
+                        // Supports both specific files and entire folders
+                        const relativePath = path_1.default
+                            .relative(process.cwd(), targetFilePath)
+                            .replace(/\\/g, '/');
+                        const isOverridden = overrides.some((o) => {
+                            const overridePath = o.replace(/\\/g, '/');
+                            return (relativePath === overridePath ||
+                                relativePath.startsWith(`${overridePath.replace(/\/$/, '')}/`));
+                        });
+                        if (isOverridden) {
+                            console.log(picocolors_1.default.yellow(`    ⚠️  Skipping overridden item: ${relativePath}`));
+                            continue;
+                        }
+                        await fs_extra_1.default.writeFile(targetFilePath, fileItem.content);
+                    }
+                }
+                console.log(picocolors_1.default.gray(`  - Updated ${basePath}/ (${agentDef.name})`));
+            }
+        }
+    }
+}
+exports.SyncCommand = SyncCommand;

package/dist/constants/index.d.ts

@@ -0,0 +1,14 @@
+export interface AgentDefinition {
+    id: string;
+    name: string;
+    path: string;
+    detectionFiles: string[];
+}
+export interface FrameworkDefinition {
+    id: string;
+    name: string;
+    languages: string[];
+    detectionFiles: string[];
+}
+export declare const SUPPORTED_AGENTS: AgentDefinition[];
+export declare const SUPPORTED_FRAMEWORKS: FrameworkDefinition[];

package/dist/constants/index.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_FRAMEWORKS = exports.SUPPORTED_AGENTS = void 0;
+exports.SUPPORTED_AGENTS = [
+    {
+        id: 'cursor',
+        name: 'Cursor',
+        path: '.cursor/skills',
+        detectionFiles: ['.cursor', '.cursorrules'],
+    },
+    {
+        id: 'claude',
+        name: 'Claude Code',
+        path: '.claude/skills',
+        detectionFiles: ['.claude', 'CLAUDE.md'],
+    },
+    {
+        id: 'copilot',
+        name: 'GitHub Copilot',
+        path: '.github/skills',
+        detectionFiles: ['.github'],
+    },
+    {
+        id: 'antigravity',
+        name: 'Antigravity',
+        path: '.agent/skills',
+        detectionFiles: ['.agent'],
+    },
+    {
+        id: 'openai',
+        name: 'OpenAI/Generic',
+        path: '.codex/skills',
+        detectionFiles: ['.codex'],
+    },
+];
+exports.SUPPORTED_FRAMEWORKS = [
+    {
+        id: 'flutter',
+        name: 'Flutter',
+        languages: ['dart'],
+        detectionFiles: ['pubspec.yaml'],
+    },
+    {
+        id: 'nestjs',
+        name: 'NestJS',
+        languages: ['typescript', 'javascript'],
+        detectionFiles: ['package.json'], // Can be improved with scanning package.json contents
+    },
+    {
+        id: 'golang',
+        name: 'Go (Golang)',
+        languages: ['go'],
+        detectionFiles: ['go.mod'],
+    },
+    {
+        id: 'nextjs',
+        name: 'Next.js',
+        languages: ['typescript', 'javascript'],
+        detectionFiles: ['next.config.js', 'next.config.mjs'],
+    },
+    {
+        id: 'react',
+        name: 'React',
+        languages: ['typescript', 'javascript'],
+        detectionFiles: ['package.json'],
+    },
+    {
+        id: 'react-native',
+        name: 'React Native',
+        languages: ['typescript', 'javascript'],
+        detectionFiles: [],
+    },
+    {
+        id: 'angular',
+        name: 'Angular',
+        languages: ['typescript'],
+        detectionFiles: ['angular.json'],
+    },
+];

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const init_1 = require("./commands/init");
+const sync_1 = require("./commands/sync");
+const program = new commander_1.Command();
+program
+    .name('agent-skills')
+    .description('A CLI to manage and sync AI agent skills for Cursor, Claude, Copilot, and more.')
+    .version('1.0.0');
+program
+    .command('init')
+    .description('Initialize a .skillsrc configuration file interactively')
+    .action(async () => {
+    const init = new init_1.InitCommand();
+    await init.run();
+});
+program
+    .command('sync')
+    .description('Sync skills to AI Agent skill directories')
+    .action(async () => {
+    const sync = new sync_1.SyncCommand();
+    await sync.run();
+});
+program.parse();

package/dist/models/config.d.ts

@@ -0,0 +1,13 @@
+export interface SkillConfig {
+    registry: string;
+    agents: string[];
+    skills: {
+        [key: string]: {
+            enabled: boolean;
+            ref?: string;
+            exclude?: string[];
+            include?: string[];
+        };
+    };
+    custom_overrides?: string[];
+}

package/dist/models/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/types.d.ts

@@ -0,0 +1,28 @@
+export interface GitHubTreeItem {
+    path: string;
+    mode: string;
+    type: 'blob' | 'tree';
+    sha: string;
+    size?: number;
+    url: string;
+}
+export interface GitHubTreeResponse {
+    sha: string;
+    url: string;
+    tree: GitHubTreeItem[];
+    truncated: boolean;
+}
+export interface CategoryMetadata {
+    version?: string;
+    last_updated?: string;
+    tag_prefix?: string;
+}
+export interface RegistryMetadata {
+    global: {
+        author: string;
+        repository: string;
+    };
+    categories: {
+        [key: string]: CategoryMetadata;
+    };
+}

package/dist/models/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "agent-skills-standard",
+  "version": "1.0.4",
+  "description": "A CLI to manage and sync AI agent skills standard for Cursor, Claude, Copilot, and more.",
+  "main": "dist/index.js",
+  "bin": {
+    "agent-skills-standard": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "ai",
+    "agent",
+    "cursor",
+    "claude",
+    "copilot",
+    "cli",
+    "antigravity"
+  ],
+  "author": "Hoang Nguyen",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^11.1.0",
+    "fs-extra": "^11.2.0",
+    "inquirer": "^9.2.12",
+    "js-yaml": "^4.1.0",
+    "node-fetch": "^2.7.0",
+    "picocolors": "^1.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@types/fs-extra": "^11.0.4",
+    "@types/inquirer": "^9.0.7",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.10.5",
+    "@types/node-fetch": "^2.6.9",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.5",
+    "globals": "^17.0.0",
+    "jiti": "^2.6.1",
+    "prettier": "3.8.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3",
+    "typescript-eslint": "^8.53.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts",
+    "release-skill": "ts-node scripts/release-skill.ts",
+    "release-skill:dry": "ts-node scripts/release-skill.ts --dry-run",
+    "release-cli": "ts-node scripts/release-cli.ts",
+    "release-cli:dry": "ts-node scripts/release-cli.ts --dry-run",
+    "publish:dry": "pnpm publish --dry-run --no-git-checks",
+    "format": "prettier --write \"src/**/*.ts\" \"scripts/**/*.ts\"",
+    "lint": "eslint \"src/**/*.ts\" \"scripts/**/*.ts\" --fix"
+  }
+}