claudiao 1.0.0

package/dist/commands/update.d.ts

@@ -0,0 +1,4 @@
+export declare function update(options?: {
+    force?: boolean;
+    dryRun?: boolean;
+}): void;

package/dist/commands/update.js

@@ -0,0 +1,141 @@
+import { execSync } from 'node:child_process';
+import { existsSync, readdirSync, rmSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import chalk from 'chalk';
+import { getExternalRepoPath, getAgentsSource, getSkillsSource, CLAUDE_AGENTS_DIR, CLAUDE_SKILLS_DIR } from '../lib/paths.js';
+import { createSymlink, ensureDir, isSymlink, getSymlinkTarget } from '../lib/symlinks.js';
+import { banner, success, warn, heading, info } from '../lib/format.js';
+export function update(options) {
+    const force = options?.force ?? false;
+    const dryRun = options?.dryRun ?? false;
+    banner();
+    if (dryRun) {
+        info('[dry-run] Nenhuma alteracao sera feita');
+        console.log('');
+    }
+    const repoPath = getExternalRepoPath();
+    // Git pull if external repo
+    if (repoPath) {
+        heading('Atualizando repositorio...');
+        if (dryRun) {
+            info(`[dry-run] Executaria git pull em ${repoPath}`);
+        }
+        else {
+            try {
+                const result = execSync('git pull', { cwd: repoPath, encoding: 'utf-8' });
+                if (result.includes('Already up to date')) {
+                    info('Repositorio ja esta atualizado');
+                }
+                else {
+                    success('Git pull concluido');
+                    console.log(chalk.dim('    ' + result.trim()));
+                }
+            }
+            catch {
+                warn('Falha no git pull (pode ser um diretorio local sem remote)');
+            }
+        }
+    }
+    // Re-link new agents
+    const agentsSource = getAgentsSource();
+    if (agentsSource && existsSync(agentsSource)) {
+        heading(force ? 'Re-linkando todos os agentes...' : 'Verificando novos agentes...');
+        ensureDir(CLAUDE_AGENTS_DIR);
+        const agentFiles = readdirSync(agentsSource).filter(f => f.endsWith('.md'));
+        let newAgents = 0;
+        let relinkedAgents = 0;
+        for (const file of agentFiles) {
+            const source = join(agentsSource, file);
+            const target = join(CLAUDE_AGENTS_DIR, file);
+            if (!existsSync(target)) {
+                if (dryRun) {
+                    info(`[dry-run] Linkaria novo agente: ${file.replace('.md', '')}`);
+                }
+                else {
+                    createSymlink(source, target);
+                    success(`Novo agente: ${file.replace('.md', '')}`);
+                }
+                newAgents++;
+            }
+            else if (force) {
+                if (dryRun) {
+                    info(`[dry-run] Re-linkaria: ${file.replace('.md', '')}`);
+                }
+                else {
+                    createSymlink(source, target);
+                    info(`Re-linkado: ${file.replace('.md', '')}`);
+                }
+                relinkedAgents++;
+            }
+        }
+        if (newAgents === 0 && relinkedAgents === 0) {
+            info('Nenhum agente novo');
+        }
+    }
+    // Re-link new skills
+    const skillsSource = getSkillsSource();
+    if (skillsSource && existsSync(skillsSource)) {
+        heading(force ? 'Re-linkando todas as skills...' : 'Verificando novas skills...');
+        ensureDir(CLAUDE_SKILLS_DIR);
+        const skillDirs = readdirSync(skillsSource, { withFileTypes: true })
+            .filter(d => d.isDirectory())
+            .map(d => d.name);
+        let newSkills = 0;
+        let relinkedSkills = 0;
+        for (const dir of skillDirs) {
+            const source = join(skillsSource, dir);
+            const target = join(CLAUDE_SKILLS_DIR, dir);
+            if (!existsSync(target)) {
+                if (dryRun) {
+                    info(`[dry-run] Linkaria nova skill: /${dir}`);
+                }
+                else {
+                    createSymlink(source, target);
+                    success(`Nova skill: /${dir}`);
+                }
+                newSkills++;
+            }
+            else if (force) {
+                if (dryRun) {
+                    info(`[dry-run] Re-linkaria: /${dir}`);
+                }
+                else {
+                    createSymlink(source, target);
+                    info(`Re-linkada: /${dir}`);
+                }
+                relinkedSkills++;
+            }
+        }
+        if (newSkills === 0 && relinkedSkills === 0) {
+            info('Nenhuma skill nova');
+        }
+    }
+    // Clean orphan symlinks
+    heading('Verificando symlinks orfaos...');
+    let orphans = 0;
+    if (existsSync(CLAUDE_AGENTS_DIR)) {
+        for (const file of readdirSync(CLAUDE_AGENTS_DIR)) {
+            const filePath = join(CLAUDE_AGENTS_DIR, file);
+            if (isSymlink(filePath)) {
+                const target = getSymlinkTarget(filePath);
+                const resolvedTarget = target ? resolve(dirname(filePath), target) : null;
+                if (resolvedTarget && !existsSync(resolvedTarget)) {
+                    if (dryRun) {
+                        warn(`[dry-run] Removeria symlink orfao: ${file}`);
+                    }
+                    else {
+                        rmSync(filePath);
+                        warn(`Symlink orfao removido: ${file}`);
+                    }
+                    orphans++;
+                }
+            }
+        }
+    }
+    if (orphans === 0) {
+        info('Nenhum symlink orfao');
+    }
+    console.log('');
+    success('Atualizacao concluida!');
+    console.log('');
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { init } from './commands/init.js';
+import { createAgent, createSkill } from './commands/create.js';
+import { listAgents, listSkills, listPlugins } from './commands/list.js';
+import { doctor } from './commands/doctor.js';
+import { removeAgent, removeSkill } from './commands/remove.js';
+import { update } from './commands/update.js';
+import { installPlugin } from './commands/install-plugin.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+const program = new Command();
+program
+    .name('claudiao')
+    .description('Seu Claude Code no próximo nível. Agentes, skills e plugins em um comando.')
+    .version(pkg.version);
+// ============================================================
+// init
+// ============================================================
+program
+    .command('init')
+    .description('Configura tudo: instala agentes, skills, CLAUDE.md global e plugins opcionais')
+    .option('--dry-run', 'Mostra o que seria feito sem executar')
+    .action(async (options) => {
+    await init(options);
+});
+// ============================================================
+// create
+// ============================================================
+const create = program
+    .command('create')
+    .description('Cria um novo agente ou skill');
+create
+    .command('agent [description]')
+    .description('Cria um novo agente especializado a partir de uma descricao')
+    .addHelpText('after', `
+Exemplos:
+  claudiao create agent
+  claudiao create agent "Especialista em Go com foco em microservices e gRPC"
+  claudiao create agent "Agente de DevOps focado em Kubernetes e Helm charts"
+  `)
+    .action(async (description) => {
+    await createAgent(description);
+});
+create
+    .command('skill [description]')
+    .description('Cria uma nova skill (slash command) com template/checklist')
+    .addHelpText('after', `
+Exemplos:
+  claudiao create skill
+  claudiao create skill "Checklist de deploy para producao"
+  claudiao create skill "Template de postmortem de incidente"
+  `)
+    .action(async (description) => {
+    await createSkill(description);
+});
+// ============================================================
+// list
+// ============================================================
+const list = program
+    .command('list')
+    .description('Lista agentes, skills ou plugins');
+list
+    .command('agents')
+    .description('Lista todos os agentes instalados com descricao e categoria')
+    .action(() => {
+    listAgents();
+});
+list
+    .command('skills')
+    .description('Lista todas as skills instaladas (slash commands)')
+    .action(() => {
+    listSkills();
+});
+list
+    .command('plugins')
+    .description('Lista plugins da comunidade disponiveis')
+    .action(() => {
+    listPlugins();
+});
+// ============================================================
+// install plugin
+// ============================================================
+program
+    .command('install')
+    .description('Instala um plugin da comunidade')
+    .argument('<type>', 'Tipo: plugin')
+    .argument('<name>', 'Nome do plugin (superpowers, get-shit-done, claude-mem)')
+    .addHelpText('after', `
+Exemplos:
+  claudiao install plugin superpowers
+  claudiao install plugin get-shit-done
+  claudiao install plugin claude-mem
+  `)
+    .action((type, name) => {
+    if (type !== 'plugin') {
+        console.log(`Tipo "${type}" nao reconhecido. Use: claudiao install plugin <nome>`);
+        return;
+    }
+    installPlugin(name);
+});
+// ============================================================
+// remove
+// ============================================================
+const remove = program
+    .command('remove')
+    .description('Remove um agente ou skill');
+remove
+    .command('agent <name>')
+    .description('Remove um agente instalado')
+    .option('--dry-run', 'Mostra o que seria feito sem executar')
+    .action(async (name, options) => {
+    await removeAgent(name, options);
+});
+remove
+    .command('skill <name>')
+    .description('Remove uma skill instalada')
+    .option('--dry-run', 'Mostra o que seria feito sem executar')
+    .action(async (name, options) => {
+    await removeSkill(name, options);
+});
+// ============================================================
+// update
+// ============================================================
+program
+    .command('update')
+    .description('Atualiza agentes e skills do repositorio (git pull + relink)')
+    .option('--force', 'Re-linka todos os agentes e skills, nao apenas novos')
+    .option('--dry-run', 'Mostra o que seria feito sem executar')
+    .action((options) => {
+    update(options);
+});
+// ============================================================
+// doctor
+// ============================================================
+program
+    .command('doctor')
+    .description('Verifica se tudo esta instalado e funcionando corretamente')
+    .action(() => {
+    doctor();
+});
+// ============================================================
+// Parse
+// ============================================================
+try {
+    await program.parseAsync();
+}
+catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`\n  \x1b[31m✗\x1b[0m Erro inesperado: ${message}\n`);
+    process.exit(1);
+}

package/dist/lib/__tests__/frontmatter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/__tests__/frontmatter.test.js

@@ -0,0 +1,180 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { mkdtempSync, writeFileSync, existsSync } from 'node:fs';
+import { rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { parseAgentFile, parseSkillFile, serializeAgent, serializeSkill } from '../frontmatter.js';
+let tmpDir;
+afterEach(() => {
+    if (tmpDir && existsSync(tmpDir)) {
+        rmSync(tmpDir, { recursive: true, force: true });
+    }
+});
+function makeTmp() {
+    tmpDir = mkdtempSync(join(tmpdir(), 'claudiao-fm-'));
+    return tmpDir;
+}
+describe('parseAgentFile', () => {
+    it('should parse all frontmatter fields from an agent file', () => {
+        const dir = makeTmp();
+        const file = join(dir, 'test-agent.md');
+        writeFileSync(file, `---
+name: architect
+description: Decisoes de arquitetura
+tools: Read, Grep, Bash
+model: opus
+category: development
+---
+
+You are an architecture specialist.
+`);
+        const result = parseAgentFile(file);
+        expect(result.name).toBe('architect');
+        expect(result.description).toBe('Decisoes de arquitetura');
+        expect(result.tools).toEqual(['Read', 'Grep', 'Bash']);
+        expect(result.model).toBe('opus');
+        expect(result.category).toBe('development');
+        expect(result.content).toContain('architecture specialist');
+    });
+    it('should use defaults when frontmatter fields are missing', () => {
+        const dir = makeTmp();
+        const file = join(dir, 'minimal.md');
+        writeFileSync(file, `---
+name: minimal
+---
+
+Body content.
+`);
+        const result = parseAgentFile(file);
+        expect(result.name).toBe('minimal');
+        expect(result.description).toBe('');
+        expect(result.tools).toEqual(['']);
+        expect(result.model).toBe('opus');
+        expect(result.category).toBe('other');
+    });
+});
+describe('parseSkillFile', () => {
+    it('should parse all frontmatter fields from a skill file', () => {
+        const dir = makeTmp();
+        const file = join(dir, 'SKILL.md');
+        writeFileSync(file, `---
+name: security-checklist
+description: Checklist pre-deploy
+allowed-tools: Read, Grep
+model: sonnet
+---
+
+# Security Checklist
+`);
+        const result = parseSkillFile(file);
+        expect(result.name).toBe('security-checklist');
+        expect(result.description).toBe('Checklist pre-deploy');
+        expect(result.allowedTools).toEqual(['Read', 'Grep']);
+        expect(result.model).toBe('sonnet');
+        expect(result.content).toContain('Security Checklist');
+    });
+    it('should use defaults when frontmatter fields are missing', () => {
+        const dir = makeTmp();
+        const file = join(dir, 'SKILL.md');
+        writeFileSync(file, `---
+name: basic
+---
+
+Content.
+`);
+        const result = parseSkillFile(file);
+        expect(result.name).toBe('basic');
+        expect(result.description).toBe('');
+        expect(result.allowedTools).toEqual(['']);
+        expect(result.model).toBe('sonnet');
+    });
+});
+describe('serializeAgent', () => {
+    it('should produce valid markdown with frontmatter', () => {
+        const meta = {
+            name: 'test-agent',
+            description: 'A test agent',
+            tools: ['Read', 'Write', 'Bash'],
+            model: 'opus',
+            category: 'testing',
+        };
+        const output = serializeAgent(meta, '\nYou are a test agent.\n');
+        expect(output).toContain('name: test-agent');
+        expect(output).toContain('description: A test agent');
+        // gray-matter quotes values containing commas
+        expect(output).toContain("tools: 'Read, Write, Bash'");
+        expect(output).toContain('model: opus');
+        expect(output).toContain('category: testing');
+        expect(output).toContain('You are a test agent.');
+    });
+    it('should omit category when not provided', () => {
+        const meta = {
+            name: 'no-cat',
+            description: 'No category',
+            tools: ['Read'],
+            model: 'opus',
+        };
+        const output = serializeAgent(meta, '\nBody.\n');
+        // "category" appears inside "description: No category" but should not appear as its own key
+        expect(output).not.toMatch(/^category:/m);
+    });
+});
+describe('serializeSkill', () => {
+    it('should produce valid markdown with frontmatter', () => {
+        const meta = {
+            name: 'my-skill',
+            description: 'A skill',
+            allowedTools: ['Grep', 'Read'],
+            model: 'sonnet',
+        };
+        const output = serializeSkill(meta, '\nSkill body.\n');
+        expect(output).toContain('name: my-skill');
+        expect(output).toContain('description: A skill');
+        // gray-matter quotes values containing commas
+        expect(output).toContain("allowed-tools: 'Grep, Read'");
+        expect(output).toContain('model: sonnet');
+        expect(output).toContain('Skill body.');
+    });
+});
+describe('round-trip', () => {
+    it('should serialize then parse an agent and get the same data back', () => {
+        const dir = makeTmp();
+        const meta = {
+            name: 'round-trip-agent',
+            description: 'Round trip test',
+            tools: ['Read', 'Bash'],
+            model: 'opus',
+            category: 'testing',
+        };
+        const body = '\nAgent instructions here.\n';
+        const serialized = serializeAgent(meta, body);
+        const file = join(dir, 'agent.md');
+        writeFileSync(file, serialized);
+        const parsed = parseAgentFile(file);
+        expect(parsed.name).toBe(meta.name);
+        expect(parsed.description).toBe(meta.description);
+        expect(parsed.tools).toEqual(meta.tools);
+        expect(parsed.model).toBe(meta.model);
+        expect(parsed.category).toBe(meta.category);
+        expect(parsed.content).toContain('Agent instructions here.');
+    });
+    it('should serialize then parse a skill and get the same data back', () => {
+        const dir = makeTmp();
+        const meta = {
+            name: 'round-trip-skill',
+            description: 'Round trip skill test',
+            allowedTools: ['Grep', 'Write'],
+            model: 'haiku',
+        };
+        const body = '\nSkill instructions here.\n';
+        const serialized = serializeSkill(meta, body);
+        const file = join(dir, 'SKILL.md');
+        writeFileSync(file, serialized);
+        const parsed = parseSkillFile(file);
+        expect(parsed.name).toBe(meta.name);
+        expect(parsed.description).toBe(meta.description);
+        expect(parsed.allowedTools).toEqual(meta.allowedTools);
+        expect(parsed.model).toBe(meta.model);
+        expect(parsed.content).toContain('Skill instructions here.');
+    });
+});

package/dist/lib/__tests__/paths.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/__tests__/paths.test.js

@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { CLAUDE_DIR, CLAUDE_AGENTS_DIR, CLAUDE_SKILLS_DIR, getTemplatesPath } from '../paths.js';
+describe('path constants', () => {
+    it('CLAUDE_DIR should point to ~/.claude', () => {
+        expect(CLAUDE_DIR).toBe(join(homedir(), '.claude'));
+    });
+    it('CLAUDE_AGENTS_DIR should be inside CLAUDE_DIR', () => {
+        expect(CLAUDE_AGENTS_DIR).toBe(join(CLAUDE_DIR, 'agents'));
+    });
+    it('CLAUDE_SKILLS_DIR should be inside CLAUDE_DIR', () => {
+        expect(CLAUDE_SKILLS_DIR).toBe(join(CLAUDE_DIR, 'skills'));
+    });
+});
+describe('getTemplatesPath', () => {
+    it('should return a path that exists', () => {
+        const templatesPath = getTemplatesPath();
+        expect(existsSync(templatesPath)).toBe(true);
+    });
+    it('should point to a directory containing agents and/or skills', () => {
+        const templatesPath = getTemplatesPath();
+        // At minimum the templates directory itself should exist
+        // The bundled templates dir ships with the package
+        expect(typeof templatesPath).toBe('string');
+        expect(templatesPath.length).toBeGreaterThan(0);
+    });
+});

package/dist/lib/__tests__/symlinks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/__tests__/symlinks.test.js

@@ -0,0 +1,142 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { mkdtempSync, writeFileSync, existsSync, readFileSync, symlinkSync } from 'node:fs';
+import { rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { ensureDir, isSymlink, createSymlink, removeSymlink } from '../symlinks.js';
+let tmpDir;
+afterEach(() => {
+    if (tmpDir && existsSync(tmpDir)) {
+        rmSync(tmpDir, { recursive: true, force: true });
+    }
+});
+function makeTmp() {
+    tmpDir = mkdtempSync(join(tmpdir(), 'claudiao-test-'));
+    return tmpDir;
+}
+describe('ensureDir', () => {
+    it('should create nested directories that do not exist', () => {
+        const dir = join(makeTmp(), 'a', 'b', 'c');
+        expect(existsSync(dir)).toBe(false);
+        ensureDir(dir);
+        expect(existsSync(dir)).toBe(true);
+    });
+    it('should not throw when directory already exists', () => {
+        const dir = makeTmp();
+        expect(() => ensureDir(dir)).not.toThrow();
+    });
+});
+describe('isSymlink', () => {
+    it('should return true for a symlink', () => {
+        const dir = makeTmp();
+        const source = join(dir, 'source.txt');
+        const link = join(dir, 'link.txt');
+        writeFileSync(source, 'hello');
+        symlinkSync(source, link);
+        expect(isSymlink(link)).toBe(true);
+    });
+    it('should return false for a regular file', () => {
+        const dir = makeTmp();
+        const file = join(dir, 'file.txt');
+        writeFileSync(file, 'hello');
+        expect(isSymlink(file)).toBe(false);
+    });
+    it('should return false for a non-existent path', () => {
+        expect(isSymlink('/tmp/does-not-exist-xyz-123')).toBe(false);
+    });
+});
+describe('createSymlink', () => {
+    it('should create a new symlink (status: created)', () => {
+        const dir = makeTmp();
+        const source = join(dir, 'source.md');
+        const target = join(dir, 'installed', 'agent.md');
+        writeFileSync(source, '# Agent');
+        const result = createSymlink(source, target);
+        expect(result.status).toBe('created');
+        expect(isSymlink(target)).toBe(true);
+        expect(readFileSync(target, 'utf-8')).toBe('# Agent');
+    });
+    it('should skip if symlink already points to the same target (status: skipped)', () => {
+        const dir = makeTmp();
+        const source = join(dir, 'source.md');
+        const target = join(dir, 'link.md');
+        writeFileSync(source, 'content');
+        symlinkSync(source, target);
+        const result = createSymlink(source, target);
+        expect(result.status).toBe('skipped');
+        expect(isSymlink(target)).toBe(true);
+    });
+    it('should update symlink pointing to a different target (status: updated)', () => {
+        const dir = makeTmp();
+        const oldSource = join(dir, 'old.md');
+        const newSource = join(dir, 'new.md');
+        const target = join(dir, 'link.md');
+        writeFileSync(oldSource, 'old');
+        writeFileSync(newSource, 'new');
+        symlinkSync(oldSource, target);
+        const result = createSymlink(newSource, target);
+        expect(result.status).toBe('updated');
+        expect(isSymlink(target)).toBe(true);
+        expect(readFileSync(target, 'utf-8')).toBe('new');
+    });
+    it('should backup a non-symlink file before creating symlink (status: backup)', () => {
+        const dir = makeTmp();
+        const source = join(dir, 'source.md');
+        const target = join(dir, 'existing.md');
+        writeFileSync(source, 'from source');
+        writeFileSync(target, 'original content');
+        const result = createSymlink(source, target);
+        expect(result.status).toBe('backup');
+        expect(isSymlink(target)).toBe(true);
+        expect(readFileSync(target, 'utf-8')).toBe('from source');
+        expect(existsSync(target + '.bak')).toBe(true);
+        expect(readFileSync(target + '.bak', 'utf-8')).toBe('original content');
+    });
+    it('should create parent directories for the target', () => {
+        const dir = makeTmp();
+        const source = join(dir, 'source.md');
+        const target = join(dir, 'deep', 'nested', 'link.md');
+        writeFileSync(source, 'data');
+        createSymlink(source, target);
+        expect(existsSync(join(dir, 'deep', 'nested'))).toBe(true);
+        expect(isSymlink(target)).toBe(true);
+    });
+});
+describe('removeSymlink', () => {
+    it('should remove a symlink and return true', () => {
+        const dir = makeTmp();
+        const source = join(dir, 'source.md');
+        const link = join(dir, 'link.md');
+        writeFileSync(source, 'content');
+        symlinkSync(source, link);
+        const removed = removeSymlink(link);
+        expect(removed).toBe(true);
+        expect(existsSync(link)).toBe(false);
+    });
+    it('should restore backup after removing symlink', () => {
+        const dir = makeTmp();
+        const source = join(dir, 'source.md');
+        const target = join(dir, 'file.md');
+        writeFileSync(source, 'new');
+        writeFileSync(target, 'original');
+        // createSymlink backs up the original file
+        createSymlink(source, target);
+        expect(existsSync(target + '.bak')).toBe(true);
+        // removeSymlink restores the backup
+        const removed = removeSymlink(target);
+        expect(removed).toBe(true);
+        expect(existsSync(target)).toBe(true);
+        expect(isSymlink(target)).toBe(false);
+        expect(readFileSync(target, 'utf-8')).toBe('original');
+        expect(existsSync(target + '.bak')).toBe(false);
+    });
+    it('should return false for a non-symlink path', () => {
+        const dir = makeTmp();
+        const file = join(dir, 'regular.md');
+        writeFileSync(file, 'content');
+        expect(removeSymlink(file)).toBe(false);
+    });
+    it('should return false for a non-existent path', () => {
+        expect(removeSymlink('/tmp/does-not-exist-xyz-456')).toBe(false);
+    });
+});

package/dist/lib/format.d.ts

@@ -0,0 +1,13 @@
+export declare function banner(): void;
+export declare function success(msg: string): void;
+export declare function warn(msg: string): void;
+export declare function error(msg: string): void;
+export declare function info(msg: string): void;
+export declare function dim(msg: string): void;
+export declare function heading(msg: string): void;
+export declare function separator(): void;
+export declare function table(rows: Array<{
+    name: string;
+    description: string;
+    status?: string;
+}>): void;