claudiao 1.0.0

package/dist/commands/doctor.js

@@ -0,0 +1,138 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import chalk from 'chalk';
+import { CLAUDE_DIR, CLAUDE_AGENTS_DIR, CLAUDE_SKILLS_DIR, CLAUDE_MD, CONFIG_FILE, getExternalRepoPath, getAgentsSource } from '../lib/paths.js';
+import { isSymlink, getSymlinkTarget } from '../lib/symlinks.js';
+import { banner, success, warn, error, heading } from '../lib/format.js';
+export function doctor() {
+    banner();
+    heading('Diagnostico do claudiao');
+    let issues = 0;
+    // 1. Claude Code
+    try {
+        execSync('which claude', { stdio: 'pipe' });
+        success('Claude Code instalado');
+    }
+    catch {
+        warn('Claude Code nao encontrado no PATH');
+        console.log(chalk.dim('    Instale: npm install -g @anthropic-ai/claude-code'));
+        issues++;
+    }
+    // 2. ~/.claude/ exists
+    if (existsSync(CLAUDE_DIR)) {
+        success('~/.claude/ existe');
+    }
+    else {
+        error('~/.claude/ nao existe');
+        console.log(chalk.dim('    Rode: claudiao init'));
+        issues++;
+    }
+    // 3. CLAUDE.md global
+    if (existsSync(CLAUDE_MD)) {
+        if (isSymlink(CLAUDE_MD)) {
+            const target = getSymlinkTarget(CLAUDE_MD);
+            if (target && existsSync(target)) {
+                success(`CLAUDE.md global OK ${chalk.dim('→ ' + target)}`);
+            }
+            else {
+                error(`CLAUDE.md global: symlink quebrado → ${target}`);
+                issues++;
+            }
+        }
+        else {
+            warn('CLAUDE.md global existe mas nao e symlink (nao sera atualizado automaticamente)');
+        }
+    }
+    else {
+        warn('CLAUDE.md global nao instalado');
+        console.log(chalk.dim('    Rode: claudiao init'));
+        issues++;
+    }
+    // 4. Agents
+    if (existsSync(CLAUDE_AGENTS_DIR)) {
+        const agents = readdirSync(CLAUDE_AGENTS_DIR).filter(f => f.endsWith('.md'));
+        let broken = 0;
+        for (const agent of agents) {
+            const agentPath = join(CLAUDE_AGENTS_DIR, agent);
+            if (isSymlink(agentPath)) {
+                const target = getSymlinkTarget(agentPath);
+                if (!target || !existsSync(target)) {
+                    error(`Agente ${agent}: symlink quebrado → ${target}`);
+                    broken++;
+                }
+            }
+        }
+        if (broken === 0) {
+            success(`${agents.length} agentes instalados, todos OK`);
+        }
+        else {
+            error(`${broken} agente(s) com symlink quebrado`);
+            console.log(chalk.dim('    Rode: claudiao init (para reinstalar)'));
+            issues += broken;
+        }
+    }
+    else {
+        warn('Nenhum agente instalado');
+        issues++;
+    }
+    // 5. Skills
+    if (existsSync(CLAUDE_SKILLS_DIR)) {
+        const skills = readdirSync(CLAUDE_SKILLS_DIR, { withFileTypes: true })
+            .filter(d => d.isDirectory() || d.isSymbolicLink());
+        let broken = 0;
+        for (const skill of skills) {
+            const skillPath = join(CLAUDE_SKILLS_DIR, skill.name);
+            if (isSymlink(skillPath)) {
+                const target = getSymlinkTarget(skillPath);
+                if (!target || !existsSync(target)) {
+                    error(`Skill ${skill.name}: symlink quebrado → ${target}`);
+                    broken++;
+                }
+            }
+            const skillMd = join(skillPath, 'SKILL.md');
+            if (!existsSync(skillMd)) {
+                warn(`Skill ${skill.name}: falta SKILL.md`);
+            }
+        }
+        if (broken === 0) {
+            success(`${skills.length} skills instaladas, todas OK`);
+        }
+        else {
+            error(`${broken} skill(s) com symlink quebrado`);
+            issues += broken;
+        }
+    }
+    else {
+        warn('Nenhuma skill instalada');
+        issues++;
+    }
+    // 6. Config file
+    if (existsSync(CONFIG_FILE)) {
+        success('Config claudiao OK');
+    }
+    else {
+        warn('Config claudiao nao encontrado (nao e obrigatorio)');
+    }
+    // 7. Repo path
+    const repoPath = getExternalRepoPath();
+    if (repoPath) {
+        success(`Repo externo de agentes/skills: ${chalk.dim(repoPath)}`);
+    }
+    const agentsSource = getAgentsSource();
+    if (agentsSource) {
+        success(`Fonte de agentes: ${chalk.dim(agentsSource)}`);
+    }
+    else {
+        warn('Nenhuma fonte de agentes encontrada');
+    }
+    // Summary
+    console.log('');
+    if (issues === 0) {
+        console.log(chalk.green.bold('  Tudo certo! Nenhum problema encontrado.'));
+    }
+    else {
+        console.log(chalk.yellow.bold(`  ${issues} problema(s) encontrado(s). Veja as sugestoes acima.`));
+    }
+    console.log('');
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,3 @@
+export declare function init(options?: {
+    dryRun?: boolean;
+}): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,252 @@
+import { existsSync, readFileSync, writeFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { CLAUDE_DIR, CLAUDE_AGENTS_DIR, CLAUDE_SKILLS_DIR, CLAUDE_MD, CONFIG_FILE, getAgentsSource, getSkillsSource, getGlobalMdSource, getExternalRepoPath, } from '../lib/paths.js';
+import { createSymlink, ensureDir } from '../lib/symlinks.js';
+import { parseAgentFile } from '../lib/frontmatter.js';
+import { banner, success, warn, error, info, dim, heading, separator } from '../lib/format.js';
+import { PLUGINS } from '../lib/plugins.js';
+import { execSync } from 'node:child_process';
+export async function init(options) {
+    const dryRun = options?.dryRun ?? false;
+    banner();
+    if (dryRun) {
+        info('[dry-run] Nenhuma alteracao sera feita');
+        console.log('');
+    }
+    // Check prerequisites
+    heading('Verificando pre-requisitos...');
+    const hasNode = process.version;
+    success(`Node.js ${hasNode}`);
+    if (!dryRun) {
+        try {
+            execSync('which claude', { stdio: 'pipe' });
+            success('Claude Code encontrado');
+        }
+        catch {
+            warn('Claude Code nao encontrado no PATH');
+            dim('Instale com: npm install -g @anthropic-ai/claude-code');
+        }
+    }
+    else {
+        info('[dry-run] Verificaria se Claude Code esta no PATH');
+    }
+    // Resolve sources
+    const agentsSource = getAgentsSource();
+    const skillsSource = getSkillsSource();
+    const globalMdSource = getGlobalMdSource();
+    // Create ~/.claude/
+    if (!dryRun) {
+        ensureDir(CLAUDE_DIR);
+    }
+    else {
+        info('[dry-run] Criaria diretorio ~/.claude/ (se nao existir)');
+    }
+    // [1/3] Install CLAUDE.md global
+    heading('[1/3] CLAUDE.md Global');
+    dim('Regras universais de codigo, git workflow, lista de agentes/skills');
+    console.log('');
+    if (globalMdSource) {
+        if (dryRun) {
+            info(`[dry-run] Linkaria ${globalMdSource} -> ~/.claude/CLAUDE.md`);
+        }
+        else {
+            const result = createSymlink(globalMdSource, CLAUDE_MD);
+            if (result.status === 'created' || result.status === 'backup') {
+                success('~/.claude/CLAUDE.md instalado');
+            }
+            else if (result.status === 'skipped') {
+                info('CLAUDE.md ja estava instalado');
+            }
+        }
+    }
+    else {
+        warn('global-CLAUDE.md nao encontrado');
+    }
+    // [2/3] Install agents
+    heading('[2/3] Agentes');
+    dim('Especialistas que o Claude Code invoca automaticamente pelo contexto');
+    console.log('');
+    let agentCount = 0;
+    if (agentsSource && existsSync(agentsSource)) {
+        if (!dryRun) {
+            ensureDir(CLAUDE_AGENTS_DIR);
+        }
+        const agentFiles = readdirSync(agentsSource).filter(f => f.endsWith('.md'));
+        agentCount = agentFiles.length;
+        if (dryRun) {
+            for (const file of agentFiles) {
+                const source = join(agentsSource, file);
+                try {
+                    const meta = parseAgentFile(source);
+                    info(`[dry-run] Linkaria agente: ${meta.name} ${chalk.dim('— ' + meta.description.slice(0, 60))}`);
+                }
+                catch {
+                    info(`[dry-run] Linkaria agente: ${file.replace('.md', '')}`);
+                }
+            }
+            console.log('');
+            info(`[dry-run] ${agentCount} agentes seriam processados`);
+        }
+        else {
+            let installed = 0;
+            let skipped = 0;
+            for (const file of agentFiles) {
+                const source = join(agentsSource, file);
+                const target = join(CLAUDE_AGENTS_DIR, file);
+                try {
+                    const meta = parseAgentFile(source);
+                    const result = createSymlink(source, target);
+                    if (result.status === 'created' || result.status === 'backup') {
+                        success(`${meta.name} ${chalk.dim('— ' + meta.description.slice(0, 60))}`);
+                        installed++;
+                    }
+                    else {
+                        console.log(`  ${chalk.yellow('⏭')} ${meta.name} ${chalk.dim('— ja instalado')}`);
+                        skipped++;
+                    }
+                }
+                catch {
+                    const result = createSymlink(source, target);
+                    if (result.status !== 'skipped')
+                        installed++;
+                    else
+                        skipped++;
+                }
+            }
+            console.log('');
+            info(`${chalk.green(String(installed) + ' novos')} | ${chalk.dim(String(skipped) + ' ja existiam')}`);
+        }
+    }
+    else {
+        warn('Nenhum agente encontrado. Use `claudiao create agent` pra criar.');
+    }
+    // [3/3] Install skills
+    heading('[3/3] Skills');
+    dim('Slash commands com templates prontos (ex: /pr-template, /security-checklist)');
+    console.log('');
+    let skillCount = 0;
+    if (skillsSource && existsSync(skillsSource)) {
+        if (!dryRun) {
+            ensureDir(CLAUDE_SKILLS_DIR);
+        }
+        const skillDirs = readdirSync(skillsSource, { withFileTypes: true })
+            .filter(d => d.isDirectory())
+            .map(d => d.name);
+        skillCount = skillDirs.length;
+        if (dryRun) {
+            for (const dir of skillDirs) {
+                info(`[dry-run] Linkaria skill: /${dir}`);
+            }
+            console.log('');
+            info(`[dry-run] ${skillCount} skills seriam processadas`);
+        }
+        else {
+            let installed = 0;
+            let skipped = 0;
+            for (const dir of skillDirs) {
+                const source = join(skillsSource, dir);
+                const target = join(CLAUDE_SKILLS_DIR, dir);
+                const result = createSymlink(source, target);
+                if (result.status === 'created' || result.status === 'backup') {
+                    success(`/${dir}`);
+                    installed++;
+                }
+                else {
+                    console.log(`  ${chalk.yellow('⏭')} /${dir} ${chalk.dim('— ja instalada')}`);
+                    skipped++;
+                }
+            }
+            console.log('');
+            info(`${chalk.green(String(installed) + ' novas')} | ${chalk.dim(String(skipped) + ' ja existiam')}`);
+        }
+    }
+    else {
+        warn('Nenhuma skill encontrada. Use `claudiao create skill` pra criar.');
+    }
+    // Ask about plugins
+    if (dryRun) {
+        console.log('');
+        info('[dry-run] Pulando prompts de plugins');
+        info('[dry-run] Plugins disponiveis: superpowers, get-shit-done, claude-mem');
+    }
+    else {
+        console.log('');
+        const { installPlugins } = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'installPlugins',
+                message: 'Quer instalar plugins da comunidade? (superpowers, get-shit-done, claude-mem)',
+                default: false,
+            }]);
+        if (installPlugins) {
+            heading('Plugins da Comunidade');
+            for (const plugin of PLUGINS) {
+                console.log('');
+                console.log(`  ${chalk.bold(plugin.name)} ${plugin.stars ? chalk.dim(`(${plugin.stars} stars)`) : ''}`);
+                dim(plugin.description);
+                dim(`Repo: ${plugin.repo}`);
+                console.log('');
+                const { install } = await inquirer.prompt([{
+                        type: 'confirm',
+                        name: 'install',
+                        message: `  Instalar ${plugin.name}?`,
+                        default: false,
+                    }]);
+                if (install) {
+                    try {
+                        execSync(plugin.installCommand, { stdio: 'inherit' });
+                        success(`${plugin.name} instalado`);
+                    }
+                    catch {
+                        error(`Falha ao instalar ${plugin.name}. Tente manualmente: ${plugin.installCommand}`);
+                    }
+                }
+            }
+        }
+    }
+    // Save config — preserve existing repoPath if current source is unavailable
+    if (dryRun) {
+        info('[dry-run] Salvaria configuracao em .claudiao.json');
+    }
+    else {
+        let existingConfig = {};
+        if (existsSync(CONFIG_FILE)) {
+            try {
+                existingConfig = JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'));
+            }
+            catch {
+                // ignore corrupt config
+            }
+        }
+        const config = {
+            repoPath: getExternalRepoPath() || existingConfig.repoPath || undefined,
+            installedAt: new Date().toISOString(),
+            version: existingConfig.version || '1.0.0',
+        };
+        writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+    }
+    // Summary
+    separator();
+    console.log(chalk.green.bold('  Pronto! claudiao configurado.'));
+    separator();
+    console.log(chalk.bold('  O que foi instalado:'));
+    if (globalMdSource)
+        console.log(`  ${chalk.green('✓')} CLAUDE.md global com regras e configuracoes`);
+    if (agentCount > 0)
+        console.log(`  ${chalk.green('✓')} ${agentCount} agentes especializados`);
+    if (skillCount > 0)
+        console.log(`  ${chalk.green('✓')} ${skillCount} skills / slash commands`);
+    console.log('');
+    console.log(chalk.bold('  Proximos passos:'));
+    console.log(`  ${chalk.cyan('1.')} Abra o terminal e rode ${chalk.yellow('claude')} em qualquer projeto`);
+    console.log(`  ${chalk.cyan('2.')} Os agentes sao ativados automaticamente pelo contexto`);
+    console.log(`  ${chalk.cyan('3.')} Use skills digitando o comando (ex: ${chalk.yellow('/security-checklist')})`);
+    console.log('');
+    console.log(chalk.bold('  Comandos uteis:'));
+    console.log(`  ${chalk.yellow('claudiao list agents')}     Lista todos os agentes instalados`);
+    console.log(`  ${chalk.yellow('claudiao list skills')}     Lista todas as skills`);
+    console.log(`  ${chalk.yellow('claudiao create agent')}    Cria um novo agente`);
+    console.log(`  ${chalk.yellow('claudiao doctor')}          Verifica se tudo esta ok`);
+    console.log('');
+}

package/dist/commands/install-plugin.d.ts

@@ -0,0 +1 @@
+export declare function installPlugin(name: string): void;

package/dist/commands/install-plugin.js

@@ -0,0 +1,35 @@
+import { execSync } from 'node:child_process';
+import chalk from 'chalk';
+import { getPlugin, PLUGINS } from '../lib/plugins.js';
+import { banner, success, error, heading, info } from '../lib/format.js';
+export function installPlugin(name) {
+    banner();
+    const plugin = getPlugin(name);
+    if (!plugin) {
+        error(`Plugin "${name}" nao encontrado.`);
+        console.log('');
+        info('Plugins disponiveis:');
+        for (const p of PLUGINS) {
+            console.log(`  ${chalk.cyan(p.name.padEnd(18))}${chalk.dim(p.description.slice(0, 60))}`);
+        }
+        console.log('');
+        return;
+    }
+    heading(`Instalando ${plugin.name}...`);
+    console.log(chalk.dim(`  ${plugin.description}`));
+    console.log(chalk.dim(`  Repo: ${plugin.repo}`));
+    console.log('');
+    console.log(chalk.dim(`  Executando: ${plugin.installCommand}`));
+    console.log('');
+    try {
+        execSync(plugin.installCommand, { stdio: 'inherit' });
+        console.log('');
+        success(`${plugin.name} instalado!`);
+    }
+    catch {
+        console.log('');
+        error(`Falha ao instalar ${plugin.name}.`);
+        info(`Tente manualmente: ${chalk.yellow(plugin.installCommand)}`);
+    }
+    console.log('');
+}

package/dist/commands/list.d.ts

@@ -0,0 +1,3 @@
+export declare function listAgents(): void;
+export declare function listSkills(): void;
+export declare function listPlugins(): void;

package/dist/commands/list.js

@@ -0,0 +1,123 @@
+import { readdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import { CLAUDE_AGENTS_DIR, CLAUDE_SKILLS_DIR } from '../lib/paths.js';
+import { parseAgentFile, parseSkillFile } from '../lib/frontmatter.js';
+import { banner, heading, table, info } from '../lib/format.js';
+import { PLUGINS } from '../lib/plugins.js';
+export function listAgents() {
+    banner();
+    heading('Agentes instalados');
+    if (!existsSync(CLAUDE_AGENTS_DIR)) {
+        info('Nenhum agente instalado. Rode `claudiao init` ou `claudiao create agent`.');
+        return;
+    }
+    const files = readdirSync(CLAUDE_AGENTS_DIR).filter(f => f.endsWith('.md'));
+    if (files.length === 0) {
+        info('Nenhum agente instalado.');
+        return;
+    }
+    const rows = files.map(file => {
+        const filePath = join(CLAUDE_AGENTS_DIR, file);
+        try {
+            const meta = parseAgentFile(filePath);
+            return {
+                name: meta.name || file.replace('.md', ''),
+                description: meta.description.slice(0, 70),
+                category: meta.category || 'other',
+                status: 'installed',
+            };
+        }
+        catch {
+            return {
+                name: file.replace('.md', ''),
+                description: chalk.dim('(erro ao ler frontmatter)'),
+                category: 'other',
+                status: 'installed',
+            };
+        }
+    });
+    // Dynamic grouping by category from frontmatter
+    const CATEGORY_LABELS = {
+        dev: 'Desenvolvimento',
+        cloud: 'Cloud & Infra',
+        quality: 'Qualidade & Seguranca',
+        planning: 'Planejamento & Gestao',
+    };
+    const CATEGORY_ORDER = ['dev', 'cloud', 'quality', 'planning'];
+    const grouped = new Map();
+    for (const row of rows) {
+        const cat = row.category;
+        if (!grouped.has(cat)) {
+            grouped.set(cat, []);
+        }
+        grouped.get(cat).push(row);
+    }
+    // Ordered categories first, then any others alphabetically
+    const orderedKeys = [
+        ...CATEGORY_ORDER.filter(k => grouped.has(k)),
+        ...[...grouped.keys()].filter(k => !CATEGORY_ORDER.includes(k)).sort(),
+    ];
+    for (const key of orderedKeys) {
+        const catRows = grouped.get(key);
+        if (catRows && catRows.length > 0) {
+            const label = CATEGORY_LABELS[key] || key.charAt(0).toUpperCase() + key.slice(1);
+            console.log(`  ${chalk.bold(label)}`);
+            table(catRows);
+            console.log('');
+        }
+    }
+    info(`${files.length} agentes instalados no total`);
+    console.log('');
+}
+export function listSkills() {
+    banner();
+    heading('Skills instaladas');
+    if (!existsSync(CLAUDE_SKILLS_DIR)) {
+        info('Nenhuma skill instalada. Rode `claudiao init` ou `claudiao create skill`.');
+        return;
+    }
+    const dirs = readdirSync(CLAUDE_SKILLS_DIR, { withFileTypes: true })
+        .filter(d => d.isDirectory() || d.isSymbolicLink());
+    if (dirs.length === 0) {
+        info('Nenhuma skill instalada.');
+        return;
+    }
+    const rows = dirs.map(d => {
+        const skillFile = join(CLAUDE_SKILLS_DIR, d.name, 'SKILL.md');
+        try {
+            if (existsSync(skillFile)) {
+                const meta = parseSkillFile(skillFile);
+                return {
+                    name: '/' + (meta.name || d.name),
+                    description: meta.description.slice(0, 70),
+                };
+            }
+        }
+        catch {
+            // fallthrough
+        }
+        return {
+            name: '/' + d.name,
+            description: '',
+        };
+    });
+    table(rows);
+    console.log('');
+    info(`${dirs.length} skills instaladas. Use digitando o comando no Claude Code.`);
+    console.log('');
+}
+export function listPlugins() {
+    banner();
+    heading('Plugins da comunidade');
+    console.log(chalk.dim('  Ferramentas extras que complementam os agentes/skills.'));
+    console.log(chalk.dim('  Instale com: claudiao install plugin <nome>'));
+    console.log('');
+    for (const plugin of PLUGINS) {
+        console.log(`  ${chalk.bold(plugin.name)} ${plugin.stars ? chalk.dim(`(${plugin.stars} stars)`) : ''}`);
+        console.log(`  ${chalk.dim(plugin.description)}`);
+        console.log(`  ${chalk.dim('Repo: ' + plugin.repo)}`);
+        console.log(`  ${chalk.dim('Instalar: ' + plugin.installCommand)}`);
+        console.log('');
+    }
+}

package/dist/commands/remove.d.ts

@@ -0,0 +1,6 @@
+export declare function removeAgent(name: string, options?: {
+    dryRun?: boolean;
+}): Promise<void>;
+export declare function removeSkill(name: string, options?: {
+    dryRun?: boolean;
+}): Promise<void>;

package/dist/commands/remove.js

@@ -0,0 +1,121 @@
+import { existsSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { CLAUDE_AGENTS_DIR, CLAUDE_SKILLS_DIR, getAgentsSavePath } from '../lib/paths.js';
+import { removeSymlink, isSymlink } from '../lib/symlinks.js';
+import { banner, success, error, heading, info } from '../lib/format.js';
+export async function removeAgent(name, options) {
+    const dryRun = options?.dryRun ?? false;
+    banner();
+    heading(`Remover agente: ${name}`);
+    if (dryRun) {
+        info('[dry-run] Nenhuma alteracao sera feita');
+        console.log('');
+    }
+    const symlinkPath = join(CLAUDE_AGENTS_DIR, `${name}.md`);
+    if (!existsSync(symlinkPath)) {
+        error(`Agente "${name}" nao encontrado em ~/.claude/agents/`);
+        console.log(chalk.dim('    Rode `claudiao list agents` pra ver os disponiveis.'));
+        return;
+    }
+    const { confirm } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'confirm',
+            message: `Remover agente "${name}"?`,
+            default: false,
+        }]);
+    if (!confirm) {
+        console.log(chalk.dim('  Cancelado.'));
+        return;
+    }
+    if (dryRun) {
+        const isLink = isSymlink(symlinkPath);
+        if (isLink) {
+            info(`[dry-run] Removeria symlink: ~/.claude/agents/${name}.md`);
+        }
+        else {
+            info(`[dry-run] Removeria arquivo: ~/.claude/agents/${name}.md`);
+        }
+    }
+    else {
+        // Remove symlink
+        const removed = removeSymlink(symlinkPath);
+        if (removed) {
+            success(`Symlink removido: ~/.claude/agents/${name}.md`);
+        }
+        else {
+            // Not a symlink, just delete
+            rmSync(symlinkPath);
+            success(`Arquivo removido: ~/.claude/agents/${name}.md`);
+        }
+    }
+    // Ask if should also remove source
+    const savePath = getAgentsSavePath();
+    if (savePath) {
+        const sourcePath = join(savePath, `${name}.md`);
+        if (existsSync(sourcePath)) {
+            if (dryRun) {
+                info(`[dry-run] Perguntaria se quer remover fonte: ${sourcePath}`);
+            }
+            else {
+                const { removeSource } = await inquirer.prompt([{
+                        type: 'confirm',
+                        name: 'removeSource',
+                        message: 'Remover tambem o arquivo fonte do repositorio?',
+                        default: false,
+                    }]);
+                if (removeSource) {
+                    rmSync(sourcePath);
+                    success(`Fonte removido: ${sourcePath}`);
+                }
+            }
+        }
+    }
+    console.log('');
+}
+export async function removeSkill(name, options) {
+    const dryRun = options?.dryRun ?? false;
+    banner();
+    heading(`Remover skill: ${name}`);
+    if (dryRun) {
+        info('[dry-run] Nenhuma alteracao sera feita');
+        console.log('');
+    }
+    const symlinkPath = join(CLAUDE_SKILLS_DIR, name);
+    if (!existsSync(symlinkPath)) {
+        error(`Skill "${name}" nao encontrada em ~/.claude/skills/`);
+        console.log(chalk.dim('    Rode `claudiao list skills` pra ver as disponiveis.'));
+        return;
+    }
+    const { confirm } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'confirm',
+            message: `Remover skill "/${name}"?`,
+            default: false,
+        }]);
+    if (!confirm) {
+        console.log(chalk.dim('  Cancelado.'));
+        return;
+    }
+    if (dryRun) {
+        const isLink = isSymlink(symlinkPath);
+        if (isLink) {
+            info(`[dry-run] Removeria symlink: ~/.claude/skills/${name}`);
+        }
+        else {
+            info(`[dry-run] Removeria diretorio: ~/.claude/skills/${name}`);
+        }
+    }
+    else {
+        const removed = removeSymlink(symlinkPath);
+        if (removed) {
+            success(`Symlink removido: ~/.claude/skills/${name}`);
+        }
+        else {
+            rmSync(symlinkPath, { recursive: true });
+            success(`Diretorio removido: ~/.claude/skills/${name}`);
+        }
+    }
+    console.log('');
+}