@agentskill.sh/cli 1.0.8 → 2.0.0

package/dist/agents.d.ts

@@ -0,0 +1,10 @@
+import type { AgentConfig, AgentType } from './types.js';
+export declare const agents: Record<AgentType, AgentConfig>;
+/** Detect all agents installed on the machine */
+export declare function detectInstalledAgents(): Promise<AgentType[]>;
+/** Agents that use the universal .agents/skills directory */
+export declare function getUniversalAgents(): AgentType[];
+/** Agents that need their own skill directory */
+export declare function getNonUniversalAgents(): AgentType[];
+export declare function isUniversalAgent(type: AgentType): boolean;
+export declare function getAgentDisplayName(type: AgentType): string;

package/dist/agents.js

@@ -0,0 +1,347 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync } from 'fs';
+const home = homedir();
+const configHome = process.env.XDG_CONFIG_HOME || join(home, '.config');
+const codexHome = process.env.CODEX_HOME?.trim() || join(home, '.codex');
+const claudeHome = process.env.CLAUDE_CONFIG_DIR?.trim() || join(home, '.claude');
+export const agents = {
+    // Universal agents (use .agents/skills)
+    amp: {
+        name: 'amp',
+        displayName: 'Amp',
+        skillsDir: '.agents/skills',
+        globalSkillsDir: join(configHome, 'agents/skills'),
+        detectInstalled: async () => existsSync(join(configHome, 'amp')),
+    },
+    antigravity: {
+        name: 'antigravity',
+        displayName: 'Antigravity',
+        skillsDir: '.agents/skills',
+        globalSkillsDir: join(home, '.gemini/antigravity/skills'),
+        detectInstalled: async () => existsSync(join(home, '.gemini/antigravity')),
+    },
+    cline: {
+        name: 'cline',
+        displayName: 'Cline',
+        skillsDir: '.agents/skills',
+        globalSkillsDir: join(home, '.agents/skills'),
+        detectInstalled: async () => existsSync(join(home, '.cline')),
+    },
+    codex: {
+        name: 'codex',
+        displayName: 'Codex',
+        skillsDir: '.agents/skills',
+        globalSkillsDir: join(codexHome, 'skills'),
+        detectInstalled: async () => existsSync(codexHome) || existsSync('/etc/codex'),
+    },
+    cursor: {
+        name: 'cursor',
+        displayName: 'Cursor',
+        skillsDir: '.agents/skills',
+        globalSkillsDir: join(home, '.cursor/skills'),
+        detectInstalled: async () => existsSync(join(home, '.cursor')),
+    },
+    deepagents: {
+        name: 'deepagents',
+        displayName: 'Deep Agents',
+        skillsDir: '.agents/skills',
+        globalSkillsDir: join(home, '.deepagents/agent/skills'),
+        detectInstalled: async () => existsSync(join(home, '.deepagents')),
+    },
+    firebender: {
+        name: 'firebender',
+        displayName: 'Firebender',
+        skillsDir: '.agents/skills',
+        globalSkillsDir: join(home, '.firebender/skills'),
+        detectInstalled: async () => existsSync(join(home, '.firebender')),
+    },
+    'gemini-cli': {
+        name: 'gemini-cli',
+        displayName: 'Gemini CLI',
+        skillsDir: '.agents/skills',
+        globalSkillsDir: join(home, '.gemini/skills'),
+        detectInstalled: async () => existsSync(join(home, '.gemini')),
+    },
+    'github-copilot': {
+        name: 'github-copilot',
+        displayName: 'GitHub Copilot',
+        skillsDir: '.agents/skills',
+        globalSkillsDir: join(home, '.copilot/skills'),
+        detectInstalled: async () => existsSync(join(home, '.copilot')),
+    },
+    'kimi-cli': {
+        name: 'kimi-cli',
+        displayName: 'Kimi Code CLI',
+        skillsDir: '.agents/skills',
+        globalSkillsDir: join(configHome, 'agents/skills'),
+        detectInstalled: async () => existsSync(join(home, '.kimi')),
+    },
+    opencode: {
+        name: 'opencode',
+        displayName: 'OpenCode',
+        skillsDir: '.agents/skills',
+        globalSkillsDir: join(configHome, 'opencode/skills'),
+        detectInstalled: async () => existsSync(join(configHome, 'opencode')),
+    },
+    warp: {
+        name: 'warp',
+        displayName: 'Warp',
+        skillsDir: '.agents/skills',
+        globalSkillsDir: join(home, '.agents/skills'),
+        detectInstalled: async () => existsSync(join(home, '.warp')),
+    },
+    // Non-universal agents (agent-specific skill dirs)
+    augment: {
+        name: 'augment',
+        displayName: 'Augment',
+        skillsDir: '.augment/skills',
+        globalSkillsDir: join(home, '.augment/skills'),
+        detectInstalled: async () => existsSync(join(home, '.augment')),
+    },
+    bob: {
+        name: 'bob',
+        displayName: 'IBM Bob',
+        skillsDir: '.bob/skills',
+        globalSkillsDir: join(home, '.bob/skills'),
+        detectInstalled: async () => existsSync(join(home, '.bob')),
+    },
+    'claude-code': {
+        name: 'claude-code',
+        displayName: 'Claude Code',
+        skillsDir: '.claude/skills',
+        globalSkillsDir: join(claudeHome, 'skills'),
+        detectInstalled: async () => existsSync(claudeHome),
+    },
+    openclaw: {
+        name: 'openclaw',
+        displayName: 'OpenClaw',
+        skillsDir: 'skills',
+        globalSkillsDir: join(home, '.openclaw/skills'),
+        detectInstalled: async () => existsSync(join(home, '.openclaw')) ||
+            existsSync(join(home, '.clawdbot')) ||
+            existsSync(join(home, '.moltbot')),
+    },
+    codebuddy: {
+        name: 'codebuddy',
+        displayName: 'CodeBuddy',
+        skillsDir: '.codebuddy/skills',
+        globalSkillsDir: join(home, '.codebuddy/skills'),
+        detectInstalled: async () => existsSync(join(home, '.codebuddy')),
+    },
+    'command-code': {
+        name: 'command-code',
+        displayName: 'Command Code',
+        skillsDir: '.commandcode/skills',
+        globalSkillsDir: join(home, '.commandcode/skills'),
+        detectInstalled: async () => existsSync(join(home, '.commandcode')),
+    },
+    continue: {
+        name: 'continue',
+        displayName: 'Continue',
+        skillsDir: '.continue/skills',
+        globalSkillsDir: join(home, '.continue/skills'),
+        detectInstalled: async () => existsSync(join(home, '.continue')),
+    },
+    cortex: {
+        name: 'cortex',
+        displayName: 'Cortex Code',
+        skillsDir: '.cortex/skills',
+        globalSkillsDir: join(home, '.snowflake/cortex/skills'),
+        detectInstalled: async () => existsSync(join(home, '.snowflake/cortex')),
+    },
+    crush: {
+        name: 'crush',
+        displayName: 'Crush',
+        skillsDir: '.crush/skills',
+        globalSkillsDir: join(configHome, 'crush/skills'),
+        detectInstalled: async () => existsSync(join(configHome, 'crush')),
+    },
+    droid: {
+        name: 'droid',
+        displayName: 'Droid',
+        skillsDir: '.factory/skills',
+        globalSkillsDir: join(home, '.factory/skills'),
+        detectInstalled: async () => existsSync(join(home, '.factory')),
+    },
+    goose: {
+        name: 'goose',
+        displayName: 'Goose',
+        skillsDir: '.goose/skills',
+        globalSkillsDir: join(configHome, 'goose/skills'),
+        detectInstalled: async () => existsSync(join(configHome, 'goose')),
+    },
+    junie: {
+        name: 'junie',
+        displayName: 'Junie',
+        skillsDir: '.junie/skills',
+        globalSkillsDir: join(home, '.junie/skills'),
+        detectInstalled: async () => existsSync(join(home, '.junie')),
+    },
+    'iflow-cli': {
+        name: 'iflow-cli',
+        displayName: 'iFlow CLI',
+        skillsDir: '.iflow/skills',
+        globalSkillsDir: join(home, '.iflow/skills'),
+        detectInstalled: async () => existsSync(join(home, '.iflow')),
+    },
+    kilo: {
+        name: 'kilo',
+        displayName: 'Kilo Code',
+        skillsDir: '.kilocode/skills',
+        globalSkillsDir: join(home, '.kilocode/skills'),
+        detectInstalled: async () => existsSync(join(home, '.kilocode')),
+    },
+    'kiro-cli': {
+        name: 'kiro-cli',
+        displayName: 'Kiro CLI',
+        skillsDir: '.kiro/skills',
+        globalSkillsDir: join(home, '.kiro/skills'),
+        detectInstalled: async () => existsSync(join(home, '.kiro')),
+    },
+    kode: {
+        name: 'kode',
+        displayName: 'Kode',
+        skillsDir: '.kode/skills',
+        globalSkillsDir: join(home, '.kode/skills'),
+        detectInstalled: async () => existsSync(join(home, '.kode')),
+    },
+    mcpjam: {
+        name: 'mcpjam',
+        displayName: 'MCPJam',
+        skillsDir: '.mcpjam/skills',
+        globalSkillsDir: join(home, '.mcpjam/skills'),
+        detectInstalled: async () => existsSync(join(home, '.mcpjam')),
+    },
+    'mistral-vibe': {
+        name: 'mistral-vibe',
+        displayName: 'Mistral Vibe',
+        skillsDir: '.vibe/skills',
+        globalSkillsDir: join(home, '.vibe/skills'),
+        detectInstalled: async () => existsSync(join(home, '.vibe')),
+    },
+    mux: {
+        name: 'mux',
+        displayName: 'Mux',
+        skillsDir: '.mux/skills',
+        globalSkillsDir: join(home, '.mux/skills'),
+        detectInstalled: async () => existsSync(join(home, '.mux')),
+    },
+    openhands: {
+        name: 'openhands',
+        displayName: 'OpenHands',
+        skillsDir: '.openhands/skills',
+        globalSkillsDir: join(home, '.openhands/skills'),
+        detectInstalled: async () => existsSync(join(home, '.openhands')),
+    },
+    pi: {
+        name: 'pi',
+        displayName: 'Pi',
+        skillsDir: '.pi/skills',
+        globalSkillsDir: join(home, '.pi/agent/skills'),
+        detectInstalled: async () => existsSync(join(home, '.pi/agent')),
+    },
+    qoder: {
+        name: 'qoder',
+        displayName: 'Qoder',
+        skillsDir: '.qoder/skills',
+        globalSkillsDir: join(home, '.qoder/skills'),
+        detectInstalled: async () => existsSync(join(home, '.qoder')),
+    },
+    'qwen-code': {
+        name: 'qwen-code',
+        displayName: 'Qwen Code',
+        skillsDir: '.qwen/skills',
+        globalSkillsDir: join(home, '.qwen/skills'),
+        detectInstalled: async () => existsSync(join(home, '.qwen')),
+    },
+    roo: {
+        name: 'roo',
+        displayName: 'Roo Code',
+        skillsDir: '.roo/skills',
+        globalSkillsDir: join(home, '.roo/skills'),
+        detectInstalled: async () => existsSync(join(home, '.roo')),
+    },
+    trae: {
+        name: 'trae',
+        displayName: 'Trae',
+        skillsDir: '.trae/skills',
+        globalSkillsDir: join(home, '.trae/skills'),
+        detectInstalled: async () => existsSync(join(home, '.trae')),
+    },
+    'trae-cn': {
+        name: 'trae-cn',
+        displayName: 'Trae CN',
+        skillsDir: '.trae/skills',
+        globalSkillsDir: join(home, '.trae-cn/skills'),
+        detectInstalled: async () => existsSync(join(home, '.trae-cn')),
+    },
+    windsurf: {
+        name: 'windsurf',
+        displayName: 'Windsurf',
+        skillsDir: '.windsurf/skills',
+        globalSkillsDir: join(home, '.codeium/windsurf/skills'),
+        detectInstalled: async () => existsSync(join(home, '.codeium/windsurf')),
+    },
+    zencoder: {
+        name: 'zencoder',
+        displayName: 'Zencoder',
+        skillsDir: '.zencoder/skills',
+        globalSkillsDir: join(home, '.zencoder/skills'),
+        detectInstalled: async () => existsSync(join(home, '.zencoder')),
+    },
+    neovate: {
+        name: 'neovate',
+        displayName: 'Neovate',
+        skillsDir: '.neovate/skills',
+        globalSkillsDir: join(home, '.neovate/skills'),
+        detectInstalled: async () => existsSync(join(home, '.neovate')),
+    },
+    pochi: {
+        name: 'pochi',
+        displayName: 'Pochi',
+        skillsDir: '.pochi/skills',
+        globalSkillsDir: join(home, '.pochi/skills'),
+        detectInstalled: async () => existsSync(join(home, '.pochi')),
+    },
+    adal: {
+        name: 'adal',
+        displayName: 'AdaL',
+        skillsDir: '.adal/skills',
+        globalSkillsDir: join(home, '.adal/skills'),
+        detectInstalled: async () => existsSync(join(home, '.adal')),
+    },
+    hermes: {
+        name: 'hermes',
+        displayName: 'Hermes',
+        skillsDir: '.hermes/skills',
+        globalSkillsDir: join(home, '.hermes/skills'),
+        detectInstalled: async () => existsSync(join(home, '.hermes')),
+    },
+};
+/** Detect all agents installed on the machine */
+export async function detectInstalledAgents() {
+    const results = await Promise.all(Object.entries(agents).map(async ([type, config]) => ({
+        type,
+        installed: await config.detectInstalled(),
+    })));
+    return results.filter((r) => r.installed).map((r) => r.type);
+}
+/** Agents that use the universal .agents/skills directory */
+export function getUniversalAgents() {
+    return Object.entries(agents)
+        .filter(([, config]) => config.skillsDir === '.agents/skills' && config.showInUniversalList !== false)
+        .map(([type]) => type);
+}
+/** Agents that need their own skill directory */
+export function getNonUniversalAgents() {
+    return Object.entries(agents)
+        .filter(([, config]) => config.skillsDir !== '.agents/skills')
+        .map(([type]) => type);
+}
+export function isUniversalAgent(type) {
+    return agents[type]?.skillsDir === '.agents/skills';
+}
+export function getAgentDisplayName(type) {
+    return agents[type]?.displayName || type;
+}

package/dist/api.js

@@ -1,5 +1,5 @@
 const API_BASE = 'https://agentskill.sh/api';
-const VERSION = '1.0.8';
+const VERSION = '2.0.0';
 export async function apiFetch(path, options) {
     const res = await fetch(`${API_BASE}${path}`, {
         ...options,

package/dist/commands/feedback.js

@@ -1,5 +1,6 @@
+import pc from 'picocolors';
 import { apiFetch } from '../api.js';
-import { detectPlatform } from '../platform.js';
+import { ORANGE } from '../ui.js';
 export async function feedbackCommand(args) {
     const jsonFlag = args.includes('--json');
     const filteredArgs = args.filter((a) => !a.startsWith('--'));
@@ -19,19 +20,16 @@ export async function feedbackCommand(args) {
         console.error('Score must be an integer between 1 and 5.');
         process.exit(1);
     }
-    // Normalize slug: strip leading @ if present
     const cleanSlug = slug.startsWith('@') ? slug.slice(1) : slug;
-    const platform = detectPlatform();
     const body = {
         score,
-        platform,
-        agentName: 'ags',
+        platform: 'claude-code',
+        agentName: 'agentskill-sh-cli',
         sessionId: `cli-${Date.now()}`,
         autoRated: false,
     };
     if (comment)
         body.comment = comment;
-    // If slug contains owner prefix, split it for the API
     const apiSlug = cleanSlug.includes('/') ? cleanSlug.split('/').pop() : cleanSlug;
     const owner = cleanSlug.includes('/') ? cleanSlug.split('/')[0] : undefined;
     if (owner)
@@ -50,8 +48,10 @@ export async function feedbackCommand(args) {
         }, null, 2));
         return;
     }
-    console.log(`\nFeedback submitted for "${cleanSlug}": ${score}/5`);
+    console.log();
+    console.log(pc.green('\u2713') + ` Feedback submitted for ${ORANGE(cleanSlug)}: ${pc.bold(`${score}/5`)}`);
     if (comment)
-        console.log(`Comment: ${comment}`);
-    console.log(`Community average: ${data.averageScore}/5 (${data.ratingCount} ratings)`);
+        console.log(`  Comment: ${comment}`);
+    console.log(`  Community average: ${pc.bold(`${data.averageScore}/5`)} (${data.ratingCount} ratings)`);
+    console.log();
 }

package/dist/commands/find.d.ts

@@ -0,0 +1 @@
+export declare function findCommand(args: string[]): Promise<void>;

package/dist/commands/find.js

@@ -0,0 +1,183 @@
+import * as readline from 'readline';
+import pc from 'picocolors';
+import { apiFetch } from '../api.js';
+import { truncate, ORANGE, DIM } from '../ui.js';
+const DEBOUNCE_MS = 300;
+const MAX_RESULTS = 10;
+function scoreLabel(score) {
+    if (score == null)
+        return pc.dim('n/a');
+    if (score >= 70)
+        return pc.green(String(score));
+    if (score >= 30)
+        return pc.yellow(String(score));
+    return pc.red(String(score));
+}
+function renderResults(results, selectedIndex, query) {
+    const lines = [];
+    if (!results.length && query.length > 0) {
+        lines.push(pc.dim('  No results'));
+        return lines;
+    }
+    for (let i = 0; i < results.length; i++) {
+        const r = results[i];
+        const isSelected = i === selectedIndex;
+        const prefix = isSelected ? ORANGE('\u276f ') : '  ';
+        const name = isSelected ? pc.bold(ORANGE(r.name)) : r.name;
+        const owner = DIM(`@${r.owner}`);
+        const security = scoreLabel(r.securityScore);
+        const desc = truncate(r.description || '', 40);
+        lines.push(`${prefix}${name} ${owner} ${DIM('sec:')}${security} ${DIM(desc)}`);
+    }
+    return lines;
+}
+function clearLines(count) {
+    for (let i = 0; i < count; i++) {
+        process.stdout.write('\x1b[1A\x1b[2K');
+    }
+}
+export async function findCommand(args) {
+    // Non-interactive mode: just search and print
+    if (!process.stdin.isTTY) {
+        const query = args.filter((a) => !a.startsWith('--')).join(' ');
+        if (!query) {
+            console.error('Usage: ags find <query>');
+            process.exit(1);
+        }
+        const params = new URLSearchParams({ q: query, limit: String(MAX_RESULTS) });
+        const data = await apiFetch(`/agent/search?${params}`);
+        for (const r of data.results) {
+            console.log(`${r.slug}\t${r.owner}\t${r.securityScore ?? 'n/a'}\t${r.description || ''}`);
+        }
+        return;
+    }
+    // Interactive fzf-style search
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: true,
+    });
+    // Enable raw mode for key-by-key input
+    if (process.stdin.setRawMode) {
+        process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    let query = args.filter((a) => !a.startsWith('--')).join(' ');
+    let results = [];
+    let selectedIndex = 0;
+    let lastRenderedLines = 0;
+    let debounceTimer = null;
+    let fetching = false;
+    function render() {
+        if (lastRenderedLines > 0) {
+            clearLines(lastRenderedLines);
+        }
+        const lines = [];
+        lines.push(`${ORANGE('\u276f')} ${pc.bold('Find a skill:')} ${query}${fetching ? DIM(' ...') : ''}`);
+        const resultLines = renderResults(results, selectedIndex, query);
+        lines.push(...resultLines);
+        if (results.length > 0) {
+            lines.push(DIM('  \u2191\u2193 navigate  \u21b5 install  esc quit'));
+        }
+        process.stdout.write(lines.join('\n') + '\n');
+        lastRenderedLines = lines.length;
+    }
+    async function search() {
+        if (!query.trim()) {
+            results = [];
+            selectedIndex = 0;
+            render();
+            return;
+        }
+        fetching = true;
+        render();
+        try {
+            const params = new URLSearchParams({ q: query, limit: String(MAX_RESULTS) });
+            const data = await apiFetch(`/agent/search?${params}`);
+            results = data.results;
+            selectedIndex = 0;
+        }
+        catch {
+            results = [];
+        }
+        fetching = false;
+        render();
+    }
+    function scheduleSearch() {
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(search, DEBOUNCE_MS);
+    }
+    // Initial render
+    render();
+    // If there's an initial query, search immediately
+    if (query) {
+        await search();
+    }
+    return new Promise((resolve) => {
+        process.stdin.on('data', async (data) => {
+            const key = data.toString();
+            // Escape or Ctrl+C: quit
+            if (key === '\x1b' || key === '\x03') {
+                if (lastRenderedLines > 0) {
+                    clearLines(lastRenderedLines);
+                }
+                if (process.stdin.setRawMode) {
+                    process.stdin.setRawMode(false);
+                }
+                rl.close();
+                resolve();
+                return;
+            }
+            // Enter: install selected
+            if (key === '\r' || key === '\n') {
+                if (results.length > 0 && results[selectedIndex]) {
+                    const selected = results[selectedIndex];
+                    if (lastRenderedLines > 0) {
+                        clearLines(lastRenderedLines);
+                    }
+                    if (process.stdin.setRawMode) {
+                        process.stdin.setRawMode(false);
+                    }
+                    rl.close();
+                    console.log(`\nInstalling ${ORANGE(selected.name)}...\n`);
+                    const { installCommand } = await import('./install.js');
+                    await installCommand([selected.slug]);
+                    resolve();
+                }
+                return;
+            }
+            // Up arrow
+            if (key === '\x1b[A') {
+                if (selectedIndex > 0) {
+                    selectedIndex--;
+                    render();
+                }
+                return;
+            }
+            // Down arrow
+            if (key === '\x1b[B') {
+                if (selectedIndex < results.length - 1) {
+                    selectedIndex++;
+                    render();
+                }
+                return;
+            }
+            // Backspace
+            if (key === '\x7f' || key === '\b') {
+                if (query.length > 0) {
+                    query = query.slice(0, -1);
+                    scheduleSearch();
+                    render();
+                }
+                return;
+            }
+            // Regular character input
+            if (key.length === 1 && key >= ' ') {
+                query += key;
+                scheduleSearch();
+                render();
+            }
+        });
+    });
+}

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function initCommand(args: string[]): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,82 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { writeFileSync, existsSync } from 'fs';
+import { join, basename } from 'path';
+import { ORANGE } from '../ui.js';
+export async function initCommand(args) {
+    const cwd = process.cwd();
+    const defaultName = basename(cwd);
+    // Get skill name from args or use directory name
+    let name = args.find((a) => !a.startsWith('--')) || '';
+    if (!name) {
+        const input = await p.text({
+            message: 'Skill name:',
+            placeholder: defaultName,
+            defaultValue: defaultName,
+            validate: (val) => {
+                if (!val || !val.trim())
+                    return 'Skill name is required';
+                if (!/^[a-z0-9-]+$/.test(val.trim())) {
+                    return 'Use lowercase letters, numbers, and hyphens only';
+                }
+                return undefined;
+            },
+        });
+        if (p.isCancel(input)) {
+            p.cancel('Cancelled.');
+            return;
+        }
+        name = input;
+    }
+    // Get description
+    const description = await p.text({
+        message: 'Description:',
+        placeholder: 'What does this skill do?',
+        validate: (val) => {
+            if (!val || !val.trim())
+                return 'Description is required';
+            return undefined;
+        },
+    });
+    if (p.isCancel(description)) {
+        p.cancel('Cancelled.');
+        return;
+    }
+    const skillMdPath = join(cwd, 'SKILL.md');
+    if (existsSync(skillMdPath)) {
+        const overwrite = await p.confirm({
+            message: 'SKILL.md already exists. Overwrite?',
+            initialValue: false,
+        });
+        if (p.isCancel(overwrite) || !overwrite) {
+            p.cancel('Cancelled.');
+            return;
+        }
+    }
+    const content = `---
+name: ${name}
+description: >
+  ${description.trim()}
+metadata:
+  author: ""
+  version: "1.0"
+compatibility: Requires Node.js 18+
+---
+
+# ${name}
+
+${description.trim()}
+
+## Usage
+
+<!-- Describe how an AI agent should use this skill -->
+
+## Examples
+
+<!-- Provide examples of when and how to use this skill -->
+`;
+    writeFileSync(skillMdPath, content, 'utf-8');
+    p.log.success(`Created ${ORANGE('SKILL.md')} for ${pc.bold(name)}`);
+    p.log.info(`Edit ${pc.dim(skillMdPath)} to customize your skill.`);
+    p.log.info(`Publish: ${pc.dim('Push to GitHub and submit at https://agentskill.sh/submit')}`);
+}