claudiao 1.0.0

package/dist/lib/format.js

@@ -0,0 +1,47 @@
+import chalk from 'chalk';
+export function banner() {
+    console.log('');
+    console.log(chalk.blue('╔═══════════════════════════════════════════╗'));
+    console.log(chalk.blue('║                                           ║'));
+    console.log(chalk.blue('║   ') + chalk.bold('claudiao') + chalk.dim(' — Claude no próximo nível') + chalk.blue('        ║'));
+    console.log(chalk.blue('║                                           ║'));
+    console.log(chalk.blue('╚═══════════════════════════════════════════╝'));
+    console.log('');
+}
+export function success(msg) {
+    console.log(chalk.green('  ✓ ') + msg);
+}
+export function warn(msg) {
+    console.log(chalk.yellow('  ⚠ ') + msg);
+}
+export function error(msg) {
+    console.log(chalk.red('  ✗ ') + msg);
+}
+export function info(msg) {
+    console.log(chalk.cyan('  ℹ ') + msg);
+}
+export function dim(msg) {
+    console.log(chalk.dim('    ' + msg));
+}
+export function heading(msg) {
+    console.log('');
+    console.log(chalk.bold(msg));
+    console.log('');
+}
+export function separator() {
+    console.log('');
+    console.log(chalk.blue('═══════════════════════════════════════════'));
+    console.log('');
+}
+export function table(rows) {
+    const maxName = Math.max(...rows.map(r => r.name.length), 4);
+    for (const row of rows) {
+        const name = row.name.padEnd(maxName + 2);
+        const status = row.status
+            ? row.status === 'installed'
+                ? chalk.green(' [instalado]')
+                : chalk.dim(' [não instalado]')
+            : '';
+        console.log(`  ${chalk.cyan(name)}${chalk.dim(row.description)}${status}`);
+    }
+}

package/dist/lib/frontmatter.d.ts

@@ -0,0 +1,9 @@
+import type { AgentMeta, SkillMeta } from '../types.js';
+export declare function parseAgentFile(filePath: string): AgentMeta & {
+    content: string;
+};
+export declare function parseSkillFile(filePath: string): SkillMeta & {
+    content: string;
+};
+export declare function serializeAgent(meta: AgentMeta, content: string): string;
+export declare function serializeSkill(meta: SkillMeta, content: string): string;

package/dist/lib/frontmatter.js

@@ -0,0 +1,45 @@
+import matter from 'gray-matter';
+import { readFileSync } from 'node:fs';
+export function parseAgentFile(filePath) {
+    const raw = readFileSync(filePath, 'utf-8');
+    const { data, content } = matter(raw);
+    return {
+        name: data.name || '',
+        description: data.description || '',
+        tools: (data.tools || '').split(',').map((t) => t.trim()),
+        model: data.model || 'opus',
+        category: data.category || 'other',
+        content,
+    };
+}
+export function parseSkillFile(filePath) {
+    const raw = readFileSync(filePath, 'utf-8');
+    const { data, content } = matter(raw);
+    return {
+        name: data.name || '',
+        description: data.description || '',
+        allowedTools: (data['allowed-tools'] || '').split(',').map((t) => t.trim()),
+        model: data.model || 'sonnet',
+        content,
+    };
+}
+export function serializeAgent(meta, content) {
+    const frontmatterData = {
+        name: meta.name,
+        description: meta.description,
+        tools: meta.tools.join(', '),
+        model: meta.model,
+    };
+    if (meta.category) {
+        frontmatterData.category = meta.category;
+    }
+    return matter.stringify(content, frontmatterData);
+}
+export function serializeSkill(meta, content) {
+    return matter.stringify(content, {
+        name: meta.name,
+        description: meta.description,
+        'allowed-tools': meta.allowedTools.join(', '),
+        model: meta.model,
+    });
+}

package/dist/lib/paths.d.ts

@@ -0,0 +1,33 @@
+export declare const CLAUDE_DIR: string;
+export declare const CLAUDE_AGENTS_DIR: string;
+export declare const CLAUDE_SKILLS_DIR: string;
+export declare const CLAUDE_MD: string;
+export declare const CONFIG_FILE: string;
+/**
+ * Returns the path to the templates/ directory that ships with the package.
+ * Works both in dev (src/) and prod (dist/).
+ */
+export declare function getTemplatesPath(): string;
+/**
+ * Returns the external repo path if configured (for users who also have
+ * a private repo of agents/skills linked via config).
+ */
+export declare function getExternalRepoPath(): string | null;
+/**
+ * Returns the best source for agents: external repo > bundled templates.
+ */
+export declare function getAgentsSource(): string | null;
+/**
+ * Returns the best source for skills: external repo > bundled templates.
+ */
+export declare function getSkillsSource(): string | null;
+/**
+ * Returns the global CLAUDE.md source file.
+ */
+export declare function getGlobalMdSource(): string | null;
+/**
+ * Returns the path where new agents/skills should be saved.
+ * Prefers external repo if configured, otherwise saves to templates/.
+ */
+export declare function getAgentsSavePath(): string;
+export declare function getSkillsSavePath(): string;

package/dist/lib/paths.js

@@ -0,0 +1,111 @@
+import { homedir } from 'node:os';
+import { join, resolve, dirname } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Package root: from dist/lib/ or src/lib/ go up to project root
+function findPackageRoot() {
+    let dir = resolve(__dirname, '..', '..');
+    for (let i = 0; i < 5; i++) {
+        if (existsSync(join(dir, 'package.json')))
+            return dir;
+        dir = resolve(dir, '..');
+    }
+    return resolve(__dirname, '..', '..');
+}
+const PACKAGE_ROOT = findPackageRoot();
+export const CLAUDE_DIR = join(homedir(), '.claude');
+export const CLAUDE_AGENTS_DIR = join(CLAUDE_DIR, 'agents');
+export const CLAUDE_SKILLS_DIR = join(CLAUDE_DIR, 'skills');
+export const CLAUDE_MD = join(CLAUDE_DIR, 'CLAUDE.md');
+export const CONFIG_FILE = join(CLAUDE_DIR, '.claudiao.json');
+/**
+ * Returns the path to the templates/ directory that ships with the package.
+ * Works both in dev (src/) and prod (dist/).
+ */
+export function getTemplatesPath() {
+    const templatesDir = join(PACKAGE_ROOT, 'templates');
+    if (existsSync(templatesDir))
+        return templatesDir;
+    return join(process.cwd(), 'templates');
+}
+/**
+ * Returns the external repo path if configured (for users who also have
+ * a private repo of agents/skills linked via config).
+ */
+export function getExternalRepoPath() {
+    if (existsSync(CONFIG_FILE)) {
+        try {
+            const config = JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'));
+            if (config.repoPath && existsSync(join(config.repoPath, 'agents'))) {
+                return config.repoPath;
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return null;
+}
+/**
+ * Returns the best source for agents: external repo > bundled templates.
+ */
+export function getAgentsSource() {
+    const external = getExternalRepoPath();
+    if (external) {
+        const agentsDir = join(external, 'agents');
+        if (existsSync(agentsDir))
+            return agentsDir;
+    }
+    const bundled = join(getTemplatesPath(), 'agents');
+    if (existsSync(bundled))
+        return bundled;
+    return null;
+}
+/**
+ * Returns the best source for skills: external repo > bundled templates.
+ */
+export function getSkillsSource() {
+    const external = getExternalRepoPath();
+    if (external) {
+        const skillsDir = join(external, 'skills');
+        if (existsSync(skillsDir))
+            return skillsDir;
+    }
+    const bundled = join(getTemplatesPath(), 'skills');
+    if (existsSync(bundled))
+        return bundled;
+    return null;
+}
+/**
+ * Returns the global CLAUDE.md source file.
+ */
+export function getGlobalMdSource() {
+    const external = getExternalRepoPath();
+    if (external) {
+        const md = join(external, 'global-CLAUDE.md');
+        if (existsSync(md))
+            return md;
+    }
+    const bundled = join(getTemplatesPath(), 'global-CLAUDE.md');
+    if (existsSync(bundled))
+        return bundled;
+    return null;
+}
+/**
+ * Returns the path where new agents/skills should be saved.
+ * Prefers external repo if configured, otherwise saves to templates/.
+ */
+export function getAgentsSavePath() {
+    const external = getExternalRepoPath();
+    if (external)
+        return join(external, 'agents');
+    return join(getTemplatesPath(), 'agents');
+}
+export function getSkillsSavePath() {
+    const external = getExternalRepoPath();
+    if (external)
+        return join(external, 'skills');
+    return join(getTemplatesPath(), 'skills');
+}

package/dist/lib/plugins.d.ts

@@ -0,0 +1,3 @@
+import type { PluginInfo } from '../types.js';
+export declare const PLUGINS: PluginInfo[];
+export declare function getPlugin(name: string): PluginInfo | undefined;

package/dist/lib/plugins.js

@@ -0,0 +1,24 @@
+export const PLUGINS = [
+    {
+        name: 'superpowers',
+        description: 'TDD enforced (red-green-refactor), debugging sistematico em 4 fases, code review por severidade, git worktrees isolados, parallel agents',
+        installCommand: 'claude /plugin install superpowers',
+        repo: 'https://github.com/obra/superpowers',
+        stars: '42k+',
+    },
+    {
+        name: 'get-shit-done',
+        description: 'Planejamento spec-driven com fases (discuss, plan, execute, verify), commits atomicos, milestones, e mapeamento de codebase existente',
+        installCommand: 'npx get-shit-done-cc@latest',
+        repo: 'https://github.com/gsd-build/get-shit-done',
+    },
+    {
+        name: 'claude-mem',
+        description: 'Memoria persistente entre sessoes. Captura decisoes, bugs resolvidos e contexto automaticamente via hooks. Armazena em SQLite + busca vetorial',
+        installCommand: 'claude /plugin install claude-mem',
+        repo: 'https://github.com/thedotmack/claude-mem',
+    },
+];
+export function getPlugin(name) {
+    return PLUGINS.find(p => p.name === name);
+}

package/dist/lib/symlinks.d.ts

@@ -0,0 +1,8 @@
+export declare function ensureDir(dir: string): void;
+export declare function isSymlink(path: string): boolean;
+export declare function getSymlinkTarget(path: string): string | null;
+export interface LinkResult {
+    status: 'created' | 'updated' | 'skipped' | 'backup';
+}
+export declare function createSymlink(source: string, target: string): LinkResult;
+export declare function removeSymlink(path: string): boolean;

package/dist/lib/symlinks.js

@@ -0,0 +1,56 @@
+import { existsSync, lstatSync, mkdirSync, readlinkSync, rmSync, symlinkSync, renameSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+export function ensureDir(dir) {
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+}
+export function isSymlink(path) {
+    try {
+        return lstatSync(path).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+export function getSymlinkTarget(path) {
+    try {
+        return readlinkSync(path);
+    }
+    catch {
+        return null;
+    }
+}
+export function createSymlink(source, target) {
+    ensureDir(dirname(target));
+    if (isSymlink(target)) {
+        const currentTarget = getSymlinkTarget(target);
+        // Resolve both to absolute paths to handle relative symlinks
+        const resolvedCurrent = currentTarget ? resolve(dirname(target), currentTarget) : null;
+        const resolvedSource = resolve(source);
+        if (resolvedCurrent === resolvedSource) {
+            return { status: 'skipped' };
+        }
+        rmSync(target);
+        symlinkSync(source, target);
+        return { status: 'updated' };
+    }
+    if (existsSync(target)) {
+        renameSync(target, target + '.bak');
+        symlinkSync(source, target);
+        return { status: 'backup' };
+    }
+    symlinkSync(source, target);
+    return { status: 'created' };
+}
+export function removeSymlink(path) {
+    if (isSymlink(path)) {
+        rmSync(path);
+        // Restore backup if exists
+        if (existsSync(path + '.bak')) {
+            renameSync(path + '.bak', path);
+        }
+        return true;
+    }
+    return false;
+}

package/dist/lib/templates.d.ts

@@ -0,0 +1,26 @@
+export interface AgentTemplateInput {
+    name: string;
+    description: string;
+    title: string;
+    intro: string;
+    scope: string;
+    tools: string[];
+    model: string;
+    category: string;
+    whenToUse: string[];
+    principles: string[];
+    antiPatterns: string[];
+}
+export interface SkillTemplateInput {
+    name: string;
+    description: string;
+    title: string;
+    tools: string[];
+    model: string;
+    whenToActivate: string[];
+    templateContent: string;
+}
+export declare function renderAgentTemplate(input: AgentTemplateInput): string;
+export declare function renderSkillTemplate(input: SkillTemplateInput): string;
+export declare const DEFAULT_AGENT_TOOLS: string[];
+export declare const DEFAULT_SKILL_TOOLS: string[];

package/dist/lib/templates.js

@@ -0,0 +1,75 @@
+export function renderAgentTemplate(input) {
+    const toolsStr = input.tools.join(', ');
+    const whenToUse = input.whenToUse.map(w => `- ${w}`).join('\n');
+    const principles = input.principles.map((p, i) => `${i + 1}. ${p}`).join('\n');
+    const antiPatterns = input.antiPatterns.map(a => `- ${a}`).join('\n');
+    return `---
+name: ${input.name}
+description: ${input.description}
+tools: ${toolsStr}
+model: ${input.model}
+category: ${input.category}
+---
+
+# ${input.title}
+
+${input.intro}
+
+## Antes de comecar
+
+- Leia \`CLAUDE.md\` do projeto se existir
+- Mapeie a arquitetura atual com Glob/Grep
+- Identifique padroes e convencoes ja em uso
+
+## Escopo
+
+${input.scope}
+
+## Quando usar
+
+${whenToUse}
+
+## Ferramentas preferidas
+
+- **Glob/Grep** para mapear arquitetura e padroes do projeto
+- **Read** para analisar configs e modulos
+- **Bash** para rodar comandos
+- **Edit** para modificar codigo
+
+## Principios
+
+${principles}
+
+## Anti-Patterns que sempre flagra
+
+${antiPatterns}
+`;
+}
+export function renderSkillTemplate(input) {
+    const toolsStr = input.tools.join(', ');
+    const whenToActivate = input.whenToActivate.map(w => `- ${w}`).join('\n');
+    return `---
+name: ${input.name}
+description: ${input.description}
+allowed-tools: ${toolsStr}
+model: ${input.model}
+---
+
+# ${input.title}
+
+## Quando ativar
+
+Ative quando o usuario estiver:
+${whenToActivate}
+
+## Template
+
+${input.templateContent}
+`;
+}
+export const DEFAULT_AGENT_TOOLS = [
+    'Read', 'Write', 'Edit', 'Grep', 'Glob', 'Bash', 'WebFetch',
+];
+export const DEFAULT_SKILL_TOOLS = [
+    'Read', 'Write', 'Edit', 'Grep', 'Glob', 'Bash',
+];

package/dist/types.d.ts

@@ -0,0 +1,25 @@
+export interface AgentMeta {
+    name: string;
+    description: string;
+    tools: string[];
+    model: string;
+    category?: string;
+}
+export interface SkillMeta {
+    name: string;
+    description: string;
+    allowedTools: string[];
+    model: string;
+}
+export interface PluginInfo {
+    name: string;
+    description: string;
+    installCommand: string;
+    repo: string;
+    stars?: string;
+}
+export interface ClaudiaoConfig {
+    repoPath?: string;
+    installedAt: string;
+    version: string;
+}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "claudiao",
+  "version": "1.0.0",
+  "description": "Seu Claude Code no próximo nível. Agentes, skills e plugins em um comando.",
+  "type": "module",
+  "bin": {
+    "claudiao": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "agents",
+    "skills",
+    "cli",
+    "developer-tools"
+  ],
+  "author": "Igor Fanticheli",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "dependencies": {
+    "@sindresorhus/slugify": "^3.0.0",
+    "chalk": "^5.3.0",
+    "commander": "^13.1.0",
+    "gray-matter": "^4.0.3",
+    "inquirer": "^12.6.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.8.0",
+    "vitest": "^4.1.0"
+  }
+}