agent-skills-standard 1.1.1 → 1.2.0

package/README.md

@@ -71,6 +71,30 @@ npx agent-skills-standard sync
 
 ---
 
+## ⚙️ Configuration (`.skillsrc`)
+
+The `.skillsrc` file allows you to customize how skills are synced to your project.
+
+```yaml
+registry: https://github.com/HoangNguyen0403/agent-skills-standard
+agents: [cursor, copilot]
+skills:
+  flutter:
+    ref: flutter-v1.1.0
+    # 🚫 Exclude specific sub-skills from being synced
+    exclude: ['getx-navigation']
+    # 🔒 Protect local modifications from being overwritten
+    custom_overrides: ['bloc-state-management']
+```
+
+### Key Options
+
+- **`exclude`**: A list of skill IDs to skip during synchronization. Useful if you want the main framework guidelines but use a different library for a specific sub-task (e.g., excluding `auto-route` if you use `go_router`).
+- **`custom_overrides`**: A list of skill IDs that the CLI should **never** overwrite. Use this when you have modified a standard skill locally to fit your project's unique needs. The CLI will detect these and preserve your local version.
+- **`ref`**: Specify a specific version or tag of the skills from the registry.
+
+---
+
 ## ✨ Key Features
 
 - **🎯 Efficiency First**: Uses a "Search-on-Demand" pattern that only loads information when the AI needs it, saving its "brain power" for your code.

package/dist/commands/init.d.ts

@@ -1,3 +1,6 @@
 export declare class InitCommand {
+    private detectionService;
+    private registryService;
+    private configService;
     run(): Promise<void>;
 }

package/dist/commands/init.js

@@ -7,104 +7,33 @@ 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");
+const ConfigService_1 = require("../services/ConfigService");
+const DetectionService_1 = require("../services/DetectionService");
+const RegistryService_1 = require("../services/RegistryService");
+const project_1 = require("../utils/project");
 class InitCommand {
+    constructor() {
+        this.detectionService = new DetectionService_1.DetectionService();
+        this.registryService = new RegistryService_1.RegistryService();
+        this.configService = new ConfigService_1.ConfigService();
+    }
     async run() {
         const configPath = path_1.default.join(process.cwd(), '.skillsrc');
-        // Load package.json for dependency checks
-        const packageJsonPath = path_1.default.join(process.cwd(), 'package.json');
-        let packageDeps = {};
-        if (await fs_extra_1.default.pathExists(packageJsonPath)) {
-            try {
-                const pkg = await fs_extra_1.default.readJson(packageJsonPath);
-                packageDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-            }
-            catch (e) {
-                console.error(picocolors_1.default.red(`❌ Failed to read package.json: ${e instanceof Error ? e.message : String(e)}`));
-            }
-        }
-        // Project detection
-        const detectionResults = {};
-        for (const framework of constants_1.SUPPORTED_FRAMEWORKS) {
-            let detected = false;
-            // 1. Check characteristic files
-            for (const file of framework.detectionFiles) {
-                if (await fs_extra_1.default.pathExists(file)) {
-                    detected = true;
-                    break;
-                }
-            }
-            // 2. Check dependencies (if not yet detected)
-            if (!detected &&
-                framework.detectionDependencies &&
-                framework.detectionDependencies.length > 0) {
-                detected = framework.detectionDependencies.some((dep) => Object.prototype.hasOwnProperty.call(packageDeps, dep));
-            }
-            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 detectionResults = await this.detectionService.detectFrameworks();
+        const agentDetection = await this.detectionService.detectAgents();
         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,
-            };
-        });
+        const defaultRegistry = 'https://github.com/HoangNguyen0403/agent-skills-standard';
+        const { categories: supportedCategories, metadata } = await this.registryService.discoverRegistry(defaultRegistry);
+        const choices = constants_1.SUPPORTED_FRAMEWORKS.map((f) => ({
+            name: supportedCategories.includes(f.id)
+                ? f.name
+                : `${f.name} (Coming Soon)`,
+            value: f.id,
+        }));
         if (await fs_extra_1.default.pathExists(configPath)) {
             const { overwrite } = await inquirer_1.default.prompt([
                 {
@@ -142,56 +71,29 @@ class InitCommand {
                 type: 'input',
                 name: 'registry',
                 message: 'Skills Registry URL:',
-                default: 'https://github.com/HoangNguyen0403/agent-skills-standard',
+                default: defaultRegistry,
             },
         ]);
         const framework = answers.framework;
-        const selectedFramework = constants_1.SUPPORTED_FRAMEWORKS.find((f) => f.id === framework);
-        const isSupported = supportedCategories.includes(framework);
-        if (!isSupported) {
+        if (!supportedCategories.includes(framework)) {
             console.log(picocolors_1.default.yellow(`\nNotice: Skills for ${framework} 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(framework);
-        if (selectedFramework) {
-            selectedFramework.languages.forEach((l) => neededSkills.add(l));
-        }
-        // Special case: Next.js and React Native imply React
-        if (framework === constants_1.Framework.NextJS || framework === constants_1.Framework.ReactNative) {
-            neededSkills.add(constants_1.Framework.React);
-        }
-        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));
+        const config = this.configService.buildInitialConfig(framework, answers.agents, answers.registry, metadata);
+        const projectDeps = await (0, project_1.buildProjectDeps)();
+        this.configService.applyDependencyExclusions(config, framework, projectDeps);
+        const commentHeader = `# Auto-detected configuration generated by agent-skills-standard init
+#
+# Presence in 'skills' list = Active. To disable a skill, remove it from the list.
+# 'exclude': IDs of sub-skills to skip during sync (auto-populated with undetected skills).
+# 'custom_overrides': IDs of skills to PROTECT. Use this if you have modified a standard 
+# skill locally and don't want the CLI to overwrite it.
+#
+# Run 'ags list-skills' to view all available skills.
+`;
+        await fs_extra_1.default.writeFile(configPath, commentHeader + 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: ${framework}`));
-        console.log(picocolors_1.default.gray(`   Auto-enabled languages: ${Array.from(neededSkills)
-            .filter((s) => s !== framework)
-            .join(', ') || 'none'}`));
         console.log(picocolors_1.default.cyan('\nNext step: Run `agent-skills-standard sync` to generate rule files.'));
     }
 }

package/dist/commands/list-skills.d.ts

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

package/dist/commands/list-skills.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListSkillsCommand = 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 path_1 = __importDefault(require("path"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const constants_1 = require("../constants");
+const github_1 = require("../utils/github");
+const project_1 = require("../utils/project");
+class ListSkillsCommand {
+    async run() {
+        const choices = constants_1.SUPPORTED_FRAMEWORKS.map((f) => ({
+            name: f.name,
+            value: f.id,
+        }));
+        const { framework } = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'framework',
+                message: 'Select framework to list available skills for:',
+                choices,
+                default: choices.find((c) => c.value === constants_1.Framework.Flutter)?.value,
+            },
+        ]);
+        const projectDeps = await (0, project_1.buildProjectDeps)();
+        console.log(picocolors_1.default.green(`\nAvailable skills for ${framework}:`));
+        // Determine registry URL (from .skillsrc or default)
+        const defaultRegistry = 'https://github.com/HoangNguyen0403/agent-skills-standard';
+        let registryUrl = defaultRegistry;
+        const configPath = path_1.default.join(process.cwd(), '.skillsrc');
+        if (await fs_extra_1.default.pathExists(configPath)) {
+            const raw = await fs_extra_1.default.readFile(configPath, 'utf8');
+            const conf = js_yaml_1.default.load(raw);
+            if (conf && conf.registry)
+                registryUrl = conf.registry;
+        }
+        // Try to fetch the repo tree to list all skills under skills/<framework>/
+        let skillFolders = [];
+        try {
+            const parsed = (0, github_1.parseRegistryUrl)(registryUrl);
+            if (parsed) {
+                const treeResult = await (0, github_1.fetchRepoTree)(parsed.owner, parsed.repo);
+                if (treeResult && Array.isArray(treeResult.data.tree)) {
+                    const allFiles = treeResult.data.tree || [];
+                    skillFolders = Array.from(new Set(allFiles
+                        .filter((f) => f.path.startsWith(`skills/${framework}/`))
+                        .map((f) => {
+                        const parts = f.path.split('/');
+                        return parts[2];
+                    })
+                        .filter(Boolean)));
+                }
+            }
+        }
+        catch {
+            // ignore network errors and fall back to detection registry
+        }
+        // Fallback: use detection registry skill ids if we couldn't fetch tree
+        const detectSkills = constants_1.SKILL_DETECTION_REGISTRY[framework] || [];
+        if (!skillFolders || skillFolders.length === 0) {
+            skillFolders = detectSkills.map((s) => s.id);
+        }
+        // For each discovered skill, show whether it would be detected (if we have rules)
+        for (const skillName of skillFolders.sort()) {
+            const detectRule = detectSkills.find((x) => x.id === skillName);
+            let mark = picocolors_1.default.yellow('no-rule');
+            if (detectRule) {
+                const present = detectRule.packages.some((p) => projectDeps.has(p));
+                mark = present ? picocolors_1.default.green('detected') : picocolors_1.default.gray('not-detected');
+            }
+            console.log(`- ${skillName} (${mark})`);
+        }
+        console.log('\nTip: Use the .skillsrc exclude array to disable/enable sub-skills before running sync.');
+    }
+}
+exports.ListSkillsCommand = ListSkillsCommand;

package/dist/commands/sync.js

@@ -27,9 +27,7 @@ class SyncCommand {
             // 2. Check for skill updates before syncing
             config = await this.checkForUpdates(config, configPath);
             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 enabledCategories = Object.keys(config.skills);
             const skills = await this.assembleFromRemote(enabledCategories, config);
             await this.writeToTargets(skills, config);
             console.log(picocolors_1.default.green('✅ All skills synced successfully!'));
@@ -83,8 +81,6 @@ class SyncCommand {
             const remoteMeta = (await metaRes.json());
             const updates = [];
             for (const [cat, catConfig] of Object.entries(config.skills)) {
-                if (!catConfig.enabled)
-                    continue;
                 const remoteCat = remoteMeta.categories?.[cat];
                 if (!remoteCat || !remoteCat.version || !remoteCat.tag_prefix)
                     continue;

package/dist/constants/index.d.ts

@@ -7,7 +7,8 @@ export declare enum Agent {
     OpenAI = "openai",
     OpenCode = "opencode",
     Gemini = "gemini",
-    Roo = "roo"
+    Roo = "roo",
+    Windsurf = "windsurf"
 }
 export declare enum Framework {
     Flutter = "flutter",
@@ -18,6 +19,7 @@ export declare enum Framework {
     ReactNative = "react-native",
     Angular = "angular"
 }
+export declare const UNIVERSAL_SKILLS: string[];
 export interface AgentDefinition {
     id: Agent;
     name: string;
@@ -35,3 +37,4 @@ export declare const getAgentDefinition: (id: Agent) => AgentDefinition;
 export declare const getFrameworkDefinition: (id: Framework) => FrameworkDefinition;
 export declare const SUPPORTED_AGENTS: AgentDefinition[];
 export declare const SUPPORTED_FRAMEWORKS: FrameworkDefinition[];
+export { SKILL_DETECTION_REGISTRY, SkillDetection } from './skills';

package/dist/constants/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SUPPORTED_FRAMEWORKS = exports.SUPPORTED_AGENTS = exports.getFrameworkDefinition = exports.getAgentDefinition = exports.Framework = exports.Agent = void 0;
+exports.SKILL_DETECTION_REGISTRY = exports.SUPPORTED_FRAMEWORKS = exports.SUPPORTED_AGENTS = exports.getFrameworkDefinition = exports.getAgentDefinition = exports.UNIVERSAL_SKILLS = exports.Framework = exports.Agent = void 0;
 var Agent;
 (function (Agent) {
     Agent["Cursor"] = "cursor";
@@ -12,6 +12,7 @@ var Agent;
     Agent["OpenCode"] = "opencode";
     Agent["Gemini"] = "gemini";
     Agent["Roo"] = "roo";
+    Agent["Windsurf"] = "windsurf";
 })(Agent || (exports.Agent = Agent = {}));
 var Framework;
 (function (Framework) {
@@ -23,6 +24,7 @@ var Framework;
     Framework["ReactNative"] = "react-native";
     Framework["Angular"] = "angular";
 })(Framework || (exports.Framework = Framework = {}));
+exports.UNIVERSAL_SKILLS = ['common'];
 const getAgentDefinition = (id) => {
     switch (id) {
         case Agent.Cursor:
@@ -88,6 +90,13 @@ const getAgentDefinition = (id) => {
                 path: '.roo/skills',
                 detectionFiles: ['.roo'],
             };
+        case Agent.Windsurf:
+            return {
+                id,
+                name: 'Windsurf',
+                path: '.windsurf/skills',
+                detectionFiles: ['.windsurf', '.windsurfrules'],
+            };
     }
 };
 exports.getAgentDefinition = getAgentDefinition;
@@ -151,3 +160,5 @@ const getFrameworkDefinition = (id) => {
 exports.getFrameworkDefinition = getFrameworkDefinition;
 exports.SUPPORTED_AGENTS = Object.values(Agent).map(exports.getAgentDefinition);
 exports.SUPPORTED_FRAMEWORKS = Object.values(Framework).map(exports.getFrameworkDefinition);
+var skills_1 = require("./skills");
+Object.defineProperty(exports, "SKILL_DETECTION_REGISTRY", { enumerable: true, get: function () { return skills_1.SKILL_DETECTION_REGISTRY; } });

package/dist/constants/skills.d.ts

@@ -0,0 +1,13 @@
+/**
+ * SkillDetection defines how to automatically enable a skill based on project dependencies.
+ */
+export interface SkillDetection {
+    /** The skill ID as defined in the registry (e.g., 'riverpod-state-management') */
+    id: string;
+    /** List of npm or pub packages that indicate this skill is used */
+    packages: string[];
+}
+/**
+ * Registry of automatic skill detection rules grouped by framework.
+ */
+export declare const SKILL_DETECTION_REGISTRY: Record<string, SkillDetection[]>;

package/dist/constants/skills.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SKILL_DETECTION_REGISTRY = void 0;
+const index_1 = require("./index");
+/**
+ * Registry of automatic skill detection rules grouped by framework.
+ */
+exports.SKILL_DETECTION_REGISTRY = {
+    [index_1.Framework.Flutter]: [
+        {
+            id: 'riverpod-state-management',
+            packages: ['flutter_riverpod', 'riverpod'],
+        },
+        {
+            id: 'bloc-state-management',
+            packages: ['flutter_bloc', 'bloc'],
+        },
+        {
+            id: 'auto-route-navigation',
+            packages: ['auto_route'],
+        },
+        {
+            id: 'go-router-navigation',
+            packages: ['go_router'],
+        },
+        {
+            id: 'getx-navigation',
+            packages: ['get'],
+        },
+        {
+            id: 'getx-state-management',
+            packages: ['get'],
+        },
+        {
+            id: 'localization',
+            packages: ['easy_localization'],
+        },
+        {
+            id: 'retrofit-networking',
+            packages: ['retrofit'],
+        },
+    ],
+    [index_1.Framework.NestJS]: [
+        {
+            id: 'caching',
+            packages: ['@nestjs/cache-manager', 'cache-manager'],
+        },
+        {
+            id: 'database',
+            packages: ['@nestjs/typeorm', '@nestjs/prisma', '@nestjs/mongoose'],
+        },
+        {
+            id: 'security',
+            packages: ['@nestjs/passport', 'passport', 'helmet'],
+        },
+    ],
+};

package/dist/index.js

@@ -3,12 +3,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const init_1 = require("./commands/init");
+const list_skills_1 = require("./commands/list-skills");
 const sync_1 = require("./commands/sync");
 const program = new commander_1.Command();
 program
     .name('agent-skills-standard')
-    .description('A CLI to manage and sync AI agent skills for Cursor, Claude, Copilot, and more.')
-    .version('1.1.1');
+    .description('A CLI to manage and sync AI agent skills for Cursor, Claude, Copilot, Windsurf, and more.')
+    .version('1.2.0');
 program
     .command('init')
     .description('Initialize a .skillsrc configuration file interactively')
@@ -23,4 +24,11 @@ program
     const sync = new sync_1.SyncCommand();
     await sync.run();
 });
+program
+    .command('list-skills')
+    .description('List available framework skills and detection status')
+    .action(async () => {
+    const cmd = new list_skills_1.ListSkillsCommand();
+    await cmd.run();
+});
 program.parse();

package/dist/models/config.d.ts

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

package/dist/services/ConfigService.d.ts

@@ -0,0 +1,8 @@
+import { SkillConfig } from '../models/config';
+import { RegistryMetadata } from '../models/types';
+export declare class ConfigService {
+    buildInitialConfig(framework: string, agents: string[], registry: string, metadata: Partial<RegistryMetadata>): SkillConfig;
+    private getAllKnownCategories;
+    private createSkillEntry;
+    applyDependencyExclusions(config: SkillConfig, framework: string, projectDeps: Set<string>): void;
+}

package/dist/services/ConfigService.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigService = void 0;
+const constants_1 = require("../constants");
+class ConfigService {
+    buildInitialConfig(framework, agents, registry, metadata) {
+        const selectedFramework = constants_1.SUPPORTED_FRAMEWORKS.find((f) => f.id === framework);
+        const neededSkills = new Set();
+        constants_1.UNIVERSAL_SKILLS.forEach((s) => neededSkills.add(s));
+        neededSkills.add(framework);
+        if (selectedFramework) {
+            selectedFramework.languages.forEach((l) => neededSkills.add(l));
+        }
+        // Special cases
+        if (framework === constants_1.Framework.NextJS || framework === constants_1.Framework.ReactNative) {
+            neededSkills.add(constants_1.Framework.React);
+        }
+        const frameworkSkills = constants_1.SKILL_DETECTION_REGISTRY[framework] || [];
+        frameworkSkills.forEach((s) => neededSkills.add(s.id));
+        const config = {
+            registry,
+            agents,
+            skills: {},
+            custom_overrides: [],
+        };
+        const allKnownCategories = this.getAllKnownCategories();
+        for (const skill of [...new Set(allKnownCategories)]) {
+            if (neededSkills.has(skill)) {
+                config.skills[skill] = this.createSkillEntry(skill, metadata);
+            }
+        }
+        return config;
+    }
+    getAllKnownCategories() {
+        return [
+            ...constants_1.UNIVERSAL_SKILLS,
+            ...constants_1.SUPPORTED_FRAMEWORKS.map((f) => f.id),
+            ...constants_1.SUPPORTED_FRAMEWORKS.flatMap((f) => f.languages),
+            ...Object.values(constants_1.SKILL_DETECTION_REGISTRY).flatMap((skills) => skills.map((s) => s.id)),
+        ];
+    }
+    createSkillEntry(skill, metadata) {
+        const skillMeta = metadata.categories?.[skill];
+        let refStr;
+        if (skillMeta?.version && skillMeta?.tag_prefix) {
+            refStr = `${skillMeta.tag_prefix}${skillMeta.version}`;
+        }
+        return {
+            ref: refStr,
+        };
+    }
+    applyDependencyExclusions(config, framework, projectDeps) {
+        const frameworkSkills = constants_1.SKILL_DETECTION_REGISTRY[framework] || [];
+        for (const skill of frameworkSkills) {
+            const entry = config.skills[skill.id];
+            if (!entry)
+                continue;
+            const used = skill.packages.some((p) => projectDeps.has(p));
+            if (!used) {
+                const parent = config.skills[framework] || {};
+                const excludes = parent.exclude ? [...parent.exclude] : [];
+                if (!excludes.includes(skill.id))
+                    excludes.push(skill.id);
+                parent.exclude = excludes;
+                config.skills[framework] = parent;
+            }
+        }
+    }
+}
+exports.ConfigService = ConfigService;

package/dist/services/DetectionService.d.ts

@@ -0,0 +1,5 @@
+export declare class DetectionService {
+    detectFrameworks(): Promise<Record<string, boolean>>;
+    detectAgents(): Promise<Record<string, boolean>>;
+    private getPackageDeps;
+}

package/dist/services/DetectionService.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DetectionService = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("../constants");
+class DetectionService {
+    async detectFrameworks() {
+        const packageDeps = await this.getPackageDeps();
+        const results = {};
+        for (const framework of constants_1.SUPPORTED_FRAMEWORKS) {
+            let detected = false;
+            // 1. Check characteristic files
+            for (const file of framework.detectionFiles) {
+                if (await fs_extra_1.default.pathExists(path_1.default.join(process.cwd(), file))) {
+                    detected = true;
+                    break;
+                }
+            }
+            // 2. Check dependencies (if not yet detected)
+            if (!detected &&
+                framework.detectionDependencies &&
+                framework.detectionDependencies.length > 0) {
+                detected = framework.detectionDependencies.some((dep) => Object.prototype.hasOwnProperty.call(packageDeps, dep));
+            }
+            results[framework.id] = detected;
+        }
+        return results;
+    }
+    async detectAgents() {
+        const results = {};
+        for (const agent of constants_1.SUPPORTED_AGENTS) {
+            let detected = false;
+            for (const file of agent.detectionFiles) {
+                if (await fs_extra_1.default.pathExists(path_1.default.join(process.cwd(), file))) {
+                    detected = true;
+                    break;
+                }
+            }
+            results[agent.id] = detected;
+        }
+        return results;
+    }
+    async getPackageDeps() {
+        const packageJsonPath = path_1.default.join(process.cwd(), 'package.json');
+        if (await fs_extra_1.default.pathExists(packageJsonPath)) {
+            try {
+                const pkg = await fs_extra_1.default.readJson(packageJsonPath);
+                return { ...pkg.dependencies, ...pkg.devDependencies };
+            }
+            catch {
+                return {};
+            }
+        }
+        return {};
+    }
+}
+exports.DetectionService = DetectionService;

package/dist/services/RegistryService.d.ts

@@ -0,0 +1,7 @@
+import { RegistryMetadata } from '../models/types';
+export declare class RegistryService {
+    discoverRegistry(registryUrl: string): Promise<{
+        categories: string[];
+        metadata: Partial<RegistryMetadata>;
+    }>;
+}

package/dist/services/RegistryService.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryService = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const github_1 = require("../utils/github");
+class RegistryService {
+    async discoverRegistry(registryUrl) {
+        let categories = ['flutter', 'dart'];
+        let metadata = {};
+        try {
+            const parsed = (0, github_1.parseRegistryUrl)(registryUrl);
+            if (parsed) {
+                const treeResult = await (0, github_1.fetchRepoTree)(parsed.owner, parsed.repo);
+                if (treeResult && Array.isArray(treeResult.data.tree)) {
+                    const allFiles = treeResult.data.tree || [];
+                    const foundCategories = new Set();
+                    allFiles.forEach((f) => {
+                        if (f.path.startsWith('skills/') && f.type === 'tree') {
+                            const parts = f.path.split('/');
+                            if (parts.length === 2)
+                                foundCategories.add(parts[1]);
+                        }
+                    });
+                    if (foundCategories.size > 0)
+                        categories = Array.from(foundCategories);
+                    const metaUrl = `https://raw.githubusercontent.com/${parsed.owner}/${parsed.repo}/${treeResult.branch}/skills/metadata.json`;
+                    const metaRes = await (0, node_fetch_1.default)(metaUrl);
+                    if (metaRes.ok) {
+                        metadata = (await metaRes.json());
+                    }
+                }
+            }
+        }
+        catch {
+            // Return defaults on error
+        }
+        return { categories, metadata };
+    }
+}
+exports.RegistryService = RegistryService;

package/dist/utils/github.d.ts

@@ -0,0 +1,10 @@
+import { GitHubTreeResponse } from '../models/types';
+export declare function parseRegistryUrl(registryUrl: string): {
+    owner: string;
+    repo: string;
+} | null;
+export declare function fetchRepoTree(owner: string, repo: string, ref?: string): Promise<{
+    data: GitHubTreeResponse;
+    branch: string;
+} | null>;
+export default fetchRepoTree;

package/dist/utils/github.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRegistryUrl = parseRegistryUrl;
+exports.fetchRepoTree = fetchRepoTree;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+function parseRegistryUrl(registryUrl) {
+    const m = registryUrl.match(/github\.com\/([^/]+)\/([^/]+)/i);
+    if (!m)
+        return null;
+    return { owner: m[1], repo: m[2].replace(/\.git$/, '') };
+}
+async function fetchRepoTree(owner, repo, ref) {
+    try {
+        let branch = ref;
+        if (!branch) {
+            // Resolve default branch
+            const repoRes = await (0, node_fetch_1.default)(`https://api.github.com/repos/${owner}/${repo}`);
+            if (!repoRes.ok)
+                return null;
+            const repoData = (await repoRes.json());
+            branch = repoData.default_branch || 'main';
+        }
+        const treeUrl = `https://api.github.com/repos/${owner}/${repo}/git/trees/${branch}?recursive=1`;
+        const res = await (0, node_fetch_1.default)(treeUrl, {
+            headers: { Accept: 'application/vnd.github.v3+json' },
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        return { data, branch };
+    }
+    catch {
+        return null;
+    }
+}
+exports.default = fetchRepoTree;

package/dist/utils/project.d.ts

@@ -0,0 +1,2 @@
+export declare function buildProjectDeps(): Promise<Set<string>>;
+export default buildProjectDeps;

package/dist/utils/project.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProjectDeps = buildProjectDeps;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+async function buildProjectDeps() {
+    const set = new Set();
+    const packageJsonPath = path_1.default.join(process.cwd(), 'package.json');
+    if (await fs_extra_1.default.pathExists(packageJsonPath)) {
+        try {
+            const pkg = await fs_extra_1.default.readJson(packageJsonPath);
+            const deps = {
+                ...(pkg.dependencies || {}),
+                ...(pkg.devDependencies || {}),
+            };
+            for (const k of Object.keys(deps))
+                set.add(k);
+        }
+        catch {
+            // ignore
+        }
+    }
+    const pubspecPath = path_1.default.join(process.cwd(), 'pubspec.yaml');
+    if (await fs_extra_1.default.pathExists(pubspecPath)) {
+        try {
+            const loaded = await fs_extra_1.default.readFile(pubspecPath, 'utf8');
+            // simple parse: only collect keys inside dependencies/dev_dependencies sections
+            const lines = loaded.split(/\r?\n/);
+            let currentSection = null;
+            let sectionIndent = null;
+            for (const line of lines) {
+                const sectionMatch = line.match(/^(\s*)(dependencies|dev_dependencies)\s*:/);
+                if (sectionMatch) {
+                    currentSection = sectionMatch[2];
+                    sectionIndent = sectionMatch[1].length;
+                    continue;
+                }
+                if (!currentSection || sectionIndent === null)
+                    continue;
+                const entryMatch = line.match(/^(\s*)([a-zA-Z0-9_\-@\\/]+)\s*:/);
+                if (!entryMatch)
+                    continue;
+                const indent = entryMatch[1].length;
+                const key = entryMatch[2];
+                // only include keys that are nested under the current section and are not known non-packages
+                if (indent > sectionIndent && key !== 'sdk' && key !== 'flutter') {
+                    set.add(key);
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return set;
+}
+exports.default = buildProjectDeps;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-skills-standard",
-  "version": "1.1.1",
-  "description": "A CLI to manage and sync AI agent skills standard for Cursor, Claude, Copilot, and more.",
+  "version": "1.2.0",
+  "description": "A CLI to manage and sync AI agent skills standard for Cursor, Claude, Copilot, Windsurf, and more.",
   "main": "dist/index.js",
   "bin": {
     "agent-skills-standard": "dist/index.js",
@@ -24,7 +24,7 @@
   "dependencies": {
     "commander": "^11.1.0",
     "fs-extra": "^11.2.0",
-    "inquirer": "^9.2.12",
+    "inquirer": "^8.2.5",
     "js-yaml": "^4.1.0",
     "node-fetch": "^2.7.0",
     "picocolors": "^1.0.0"
@@ -32,7 +32,7 @@
   "devDependencies": {
     "@eslint/js": "^9.39.2",
     "@types/fs-extra": "^11.0.4",
-    "@types/inquirer": "^9.0.7",
+    "@types/inquirer": "^8.2.5",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.10.5",
     "@types/node-fetch": "^2.6.9",