@perma-tools/cli 0.0.1

package/dist/index.js

@@ -0,0 +1,537 @@
+#!/usr/bin/env node
+import { access, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { intro, isCancel, multiselect, outro, select, text, } from "@clack/prompts";
+import { optionsToConfig, parseArguments, validateOptions, } from "./cli-parser.js";
+import { GitSetup } from "./git-setup.js";
+import { ProjectGenerator } from "./project-generator.js";
+async function runHybridMode(options) {
+    const config = { ...options };
+    // 0. Nome do projeto (obrigatório)
+    if (!config.projectName) {
+        const projectName = await text({
+            message: "📝 Qual o nome do projeto?",
+            placeholder: "meu-projeto",
+            validate: (value) => {
+                if (!value)
+                    return "O nome do projeto é obrigatório";
+                // Regras do npm para nomes de pacotes
+                if (!/^[a-z0-9-]+$/.test(value)) {
+                    return "Use apenas letras minúsculas, números e hífens";
+                }
+                if (value.startsWith("-") || value.startsWith(".")) {
+                    return "O nome não pode começar com hífen ou ponto";
+                }
+                if (value.endsWith("-") || value.endsWith(".")) {
+                    return "O nome não pode terminar com hífen ou ponto";
+                }
+                if (value.length > 214) {
+                    return "O nome deve ter no máximo 214 caracteres";
+                }
+                if (/^[0-9]/.test(value)) {
+                    return "O nome não pode começar com números";
+                }
+                // Nomes reservados do npm
+                const reservedNames = ["node_modules", "favicon.ico"];
+                if (reservedNames.includes(value.toLowerCase())) {
+                    return "Este nome é reservado e não pode ser usado";
+                }
+            },
+        });
+        if (isCancel(projectName)) {
+            outro("❌ Operação cancelada");
+            process.exit(0);
+        }
+        config.projectName = projectName;
+    }
+    config.projectPath = join(process.cwd(), config.projectName);
+    // 1. Package Manager
+    if (!config.packageManager) {
+        config.packageManager = (await select({
+            message: "📦 Qual package manager deseja usar?",
+            options: [
+                { value: "pnpm", label: "pnpm" },
+                { value: "yarn", label: "yarn" },
+                { value: "npm", label: "npm" },
+            ],
+        }));
+    }
+    // 2. Tipo da aplicação
+    if (!config.applicationType) {
+        config.applicationType = (await select({
+            message: "🏗️ Qual tipo de aplicação você quer?",
+            options: [
+                { value: "frontend", label: "Frontend" },
+                { value: "backend", label: "Backend" },
+            ],
+        }));
+    }
+    // Fluxo condicional baseado no tipo de aplicação
+    if (config.applicationType === "frontend") {
+        // 3. Framework (apenas para frontend)
+        if (!config.framework) {
+            config.framework = (await select({
+                message: "⚡ Qual framework?",
+                options: [
+                    { value: "nextjs-15", label: "NextJS 15.x" },
+                    {
+                        value: "vitejs-6",
+                        label: "ViteJS 6.x (em breve)",
+                        hint: "Ainda não disponível",
+                    },
+                ],
+            }));
+            // Validar se ViteJS foi selecionado
+            if (config.framework === "vitejs-6") {
+                console.error("\n❌ ViteJS ainda não está disponível nesta versão.");
+                console.error("💡 Use NextJS 15.x ou aguarde a próxima versão.\n");
+                process.exit(1);
+            }
+        }
+        // 4. Cliente HTTP
+        if (!config.httpClient) {
+            config.httpClient = (await select({
+                message: "🌐 Qual cliente HTTP deseja usar?",
+                options: [
+                    { value: "ky", label: "ky" },
+                    { value: "axios", label: "axios" },
+                    { value: "fetch", label: "none (fetch)" },
+                ],
+            }));
+        }
+        // 5. Linter
+        if (!config.linter) {
+            config.linter = (await select({
+                message: "✨ Qual linter deseja usar?",
+                options: [
+                    { value: "biome", label: "Biome" },
+                    { value: "eslint-prettier", label: "Eslint + Prettier" },
+                ],
+            }));
+        }
+        // 6. Libs adicionais (só pergunta se não foi passado)
+        if (!config.additionalLibs || config.additionalLibs.length === 0) {
+            config.additionalLibs = (await multiselect({
+                message: "📚 Libs adicionais (pode selecionar mais de uma):",
+                options: [
+                    { value: "nuqs", label: "nuqs" },
+                    { value: "tanstack-query", label: "tanstack query" },
+                    { value: "date-fns", label: "date-fns" },
+                    { value: "zod", label: "zod" },
+                    {
+                        value: "react-hook-form",
+                        label: "react hook form + @hookform/resolvers",
+                    },
+                    { value: "cookies-next", label: "cookies-next" },
+                    { value: "framer-motion", label: "framer-motion" },
+                    { value: "lucide-react", label: "lucide-react" },
+                    { value: "recharts", label: "recharts" },
+                ],
+                required: false,
+            }));
+        }
+        // 7. shadcn/ui (só pergunta se não foi passado via flag)
+        if (config.withShadcn === undefined) {
+            const useShadcn = (await select({
+                message: "🎨 Deseja usar shadcn/ui?",
+                options: [
+                    { value: true, label: "Sim, configurar shadcn/ui" },
+                    { value: false, label: "Não" },
+                ],
+            }));
+            config.withShadcn = useShadcn;
+        }
+        // 7.1. Cor do shadcn (só pergunta se withShadcn = true e não foi passado)
+        if (config.withShadcn && !config.shadcnColor) {
+            config.shadcnColor = (await select({
+                message: "🎨 Qual cor base deseja usar no shadcn/ui?",
+                options: [
+                    { value: "neutral", label: "Neutral (cinza neutro)" },
+                    { value: "slate", label: "Slate (cinza azulado)" },
+                    { value: "gray", label: "Gray (cinza médio)" },
+                    { value: "zinc", label: "Zinc (cinza metálico)" },
+                    { value: "stone", label: "Stone (cinza terroso)" },
+                ],
+            }));
+        }
+        // 7.2. Componentes shadcn (só pergunta se withShadcn = true e não foram passados)
+        if (config.withShadcn &&
+            (!config.shadcnComponents || config.shadcnComponents.length === 0)) {
+            config.shadcnComponents = (await multiselect({
+                message: "🧩 Quais componentes do shadcn/ui deseja adicionar?",
+                options: [
+                    { value: "button", label: "button" },
+                    { value: "input", label: "input" },
+                    { value: "card", label: "card" },
+                    { value: "dialog", label: "dialog" },
+                    { value: "dropdown-menu", label: "dropdown-menu" },
+                    { value: "label", label: "label" },
+                    { value: "select", label: "select" },
+                    { value: "textarea", label: "textarea" },
+                    { value: "toast", label: "toast" },
+                    { value: "form", label: "form" },
+                    { value: "table", label: "table" },
+                    { value: "tabs", label: "tabs" },
+                ],
+                required: false,
+            }));
+        }
+    }
+    // 8. Instalar dependências automaticamente (só pergunta se não foi passado)
+    if (config.shouldInstallDeps === undefined) {
+        const shouldInstall = (await select({
+            message: "📦 Deseja instalar as dependências automaticamente?",
+            options: [
+                { value: true, label: "Sim, instalar agora" },
+                { value: false, label: "Não, vou instalar depois" },
+            ],
+        }));
+        config.shouldInstallDeps = shouldInstall;
+    }
+    // 9. Setup Git e Deploy (só pergunta se não foi passado)
+    if (config.gitSetup === undefined) {
+        // Verificar quais CLIs estão disponíveis
+        const hasGitHubCLI = await GitSetup.isGitHubCLIAvailable();
+        const hasVercelCLI = await GitSetup.isVercelCLIAvailable();
+        // Se não tem nenhuma CLI, pular essa etapa
+        if (!hasGitHubCLI) {
+            console.log("\n💡 GitHub CLI (gh) não encontrado ou não autenticado.");
+            console.log("   Para habilitar criação automática de repos, instale: https://cli.github.com/\n");
+            config.gitSetup = "none";
+        }
+        else {
+            // Mostrar aviso se não tiver Vercel CLI (para projetos frontend)
+            if (!hasVercelCLI && config.applicationType === "frontend") {
+                console.log("\n💡 Vercel CLI não encontrado. Deploy automático não estará disponível.");
+                console.log("   Para habilitar: npm i -g vercel && vercel login\n");
+            }
+            // Montar opções baseado nas CLIs disponíveis
+            const options = [];
+            // Opção de repo + deploy (só se tiver ambas CLIs e for frontend)
+            if (hasGitHubCLI &&
+                hasVercelCLI &&
+                config.applicationType === "frontend") {
+                options.push({
+                    value: "repo-and-deploy",
+                    label: "Criar repositório no GitHub e configurar deploy na Vercel",
+                    hint: "Recomendado para projetos frontend",
+                });
+            }
+            // Opção de apenas repo (sempre disponível se tiver gh CLI)
+            if (hasGitHubCLI) {
+                options.push({
+                    value: "repo-only",
+                    label: "Apenas criar repositório no GitHub",
+                    hint: "Sem configuração de deploy",
+                });
+            }
+            // Opção de não configurar (sempre disponível)
+            options.push({
+                value: "none",
+                label: "Não configurar agora",
+                hint: "Você pode configurar manualmente depois",
+            });
+            const setupOption = (await select({
+                message: "🚀 Deseja configurar repositório Git e deploy?",
+                options,
+            }));
+            config.gitSetup = setupOption;
+        }
+        // 9.1. Se escolheu criar repo, perguntar detalhes
+        if (config.gitSetup !== "none") {
+            // Nome do repositório
+            if (!config.repoName) {
+                const repoName = (await text({
+                    message: "📝 Qual o nome do repositório?",
+                    placeholder: config.projectName,
+                    initialValue: config.projectName,
+                    validate: (value) => {
+                        if (!value)
+                            return "O nome do repositório é obrigatório";
+                        if (!/^[a-zA-Z0-9._-]+$/.test(value)) {
+                            return "Use apenas letras, números, pontos, hífens e underscores";
+                        }
+                    },
+                }));
+                if (isCancel(repoName)) {
+                    outro("❌ Operação cancelada");
+                    process.exit(0);
+                }
+                config.repoName = repoName;
+            }
+            // Organização (se não foi passado via flag)
+            if (!config.repoOrg) {
+                const repoLocation = (await select({
+                    message: "📍 Onde deseja criar o repositório?",
+                    options: [
+                        {
+                            value: "personal",
+                            label: "Meu perfil pessoal",
+                            hint: "github.com/seu-usuario",
+                        },
+                        {
+                            value: "organization",
+                            label: "Em uma organização",
+                            hint: "github.com/org-name",
+                        },
+                    ],
+                }));
+                if (repoLocation === "organization") {
+                    // Buscar organizações do usuário
+                    console.log("\n🔍 Buscando suas organizações...");
+                    const orgs = await GitSetup.getGitHubOrganizations();
+                    if (orgs.length === 0) {
+                        console.log("⚠️  Nenhuma organização encontrada ou GitHub CLI não autenticado.");
+                        console.log("💡 Criando no perfil pessoal...\n");
+                    }
+                    else {
+                        const selectedOrg = (await select({
+                            message: "🏢 Selecione a organização:",
+                            options: orgs.map((org) => ({
+                                value: org,
+                                label: org,
+                            })),
+                        }));
+                        if (isCancel(selectedOrg)) {
+                            outro("❌ Operação cancelada");
+                            process.exit(0);
+                        }
+                        config.repoOrg = selectedOrg;
+                    }
+                }
+            }
+            // Visibilidade do repositório
+            if (!config.repoVisibility) {
+                config.repoVisibility = (await select({
+                    message: "🔒 Qual a visibilidade do repositório?",
+                    options: [
+                        {
+                            value: "public",
+                            label: "Público",
+                            hint: "Qualquer pessoa pode ver",
+                        },
+                        {
+                            value: "private",
+                            label: "Privado",
+                            hint: "Apenas você e colaboradores",
+                        },
+                    ],
+                }));
+            }
+        }
+    }
+    return config;
+}
+async function generateProject(config) {
+    const generator = new ProjectGenerator();
+    try {
+        // Verificar se o diretório já existe
+        try {
+            await access(config.projectPath);
+            console.error("\n❌ Erro: O diretório já existe!");
+            console.error(`   Caminho: ${config.projectPath}`);
+            console.error("\n💡 Escolha um nome diferente ou remova o diretório existente.\n");
+            process.exit(1);
+        }
+        catch {
+            // Diretório não existe, podemos prosseguir
+        }
+        // Criar diretório do projeto
+        await mkdir(config.projectPath, { recursive: true });
+        // Gerar projeto
+        await generator.generate(config);
+        // Setup Git e Deploy (se configurado)
+        if (config.gitSetup && config.gitSetup !== "none") {
+            const gitSetup = new GitSetup({
+                projectPath: config.projectPath,
+                projectName: config.projectName,
+                repoName: config.repoName,
+                repoOrg: config.repoOrg,
+                visibility: config.repoVisibility,
+                withVercel: config.gitSetup === "repo-and-deploy" &&
+                    config.applicationType === "frontend",
+            });
+            try {
+                // Inicializar Git
+                await gitSetup.initialize();
+                // Criar repositório no GitHub
+                const repoUrl = await gitSetup.createGitHubRepo();
+                console.log(`\n🔗 Repositório: ${repoUrl}`);
+                // Configurar Vercel se necessário
+                if (config.gitSetup === "repo-and-deploy" &&
+                    config.applicationType === "frontend") {
+                    await gitSetup.setupVercelDeploy();
+                }
+            }
+            catch (error) {
+                console.error("\n⚠️  Aviso: Erro ao configurar Git/Deploy:");
+                console.error(error.message);
+                console.error("\n💡 Você pode configurar manualmente depois.");
+            }
+        }
+        // Sucesso!
+        console.log("\n");
+        outro("✨ Projeto criado com sucesso!");
+        console.log("\n📋 Próximos passos:\n");
+        console.log(`  cd ${config.projectName}`);
+        if (!config.shouldInstallDeps) {
+            console.log(`  ${config.packageManager} install`);
+        }
+        if (!config.gitSetup || config.gitSetup === "none") {
+            console.log(`  git init && git add . && git commit -m "initial commit"`);
+        }
+        console.log(`  ${config.packageManager} ${config.packageManager === "npm" ? "run " : ""}dev`);
+        console.log("");
+    }
+    catch (error) {
+        console.error("\n❌ Erro ao criar projeto:", error);
+        outro("Falha ao criar o projeto");
+        process.exit(1);
+    }
+}
+async function main() {
+    // Verificar se há argumentos CLI (exceto --help e --version que o commander já trata)
+    const args = process.argv.slice(2);
+    const hasFlags = args.length > 0 &&
+        !args.every((arg) => arg === "--help" || arg === "-h" || arg === "--version" || arg === "-V");
+    if (hasFlags) {
+        // Modo CLI com flags ou híbrido
+        const options = parseArguments();
+        // Validar opções antes de prosseguir
+        const errors = validateOptions(options);
+        if (errors.length > 0) {
+            console.error("\n");
+            console.error("╔═══════════════════════════════════════════════════════════╗");
+            console.error("║                  ❌ ERRO DE VALIDAÇÃO                    ║");
+            console.error("╚═══════════════════════════════════════════════════════════╝");
+            console.error("\n");
+            errors.forEach((error) => {
+                console.error(`  ${error}`);
+            });
+            console.error("\n");
+            console.error("💡 Dica: Use --help para ver as opções disponíveis");
+            console.error("\n");
+            process.exit(1);
+        }
+        // Validar disponibilidade de CLIs se Git setup foi especificado
+        if (options.gitSetup && options.gitSetup !== "none") {
+            const hasGitHubCLI = await GitSetup.isGitHubCLIAvailable();
+            const hasVercelCLI = await GitSetup.isVercelCLIAvailable();
+            if (!hasGitHubCLI) {
+                console.error("\n❌ Erro: GitHub CLI (gh) não encontrado ou não autenticado.");
+                console.error("   Instale e autentique: https://cli.github.com/");
+                console.error("   Ou use a CLI sem --git-setup para pular essa configuração.\n");
+                process.exit(1);
+            }
+            if (options.gitSetup === "repo-and-deploy" && !hasVercelCLI) {
+                console.error("\n⚠️  Aviso: Vercel CLI não encontrado ou não autenticado.");
+                console.error("   Para deploy automático: npm i -g vercel && vercel login");
+                console.error("   Ajustando para criar apenas o repositório...\n");
+                options.gitSetup = "repo-only";
+            }
+        }
+        console.clear();
+        intro("🚀 Bem-vindo ao Gerador de Projetos!");
+        // Converter options para config parcial
+        const partialConfig = optionsToConfig(options);
+        // Executar modo híbrido (pergunta apenas o que falta)
+        const config = await runHybridMode(partialConfig);
+        // Exibir resumo final
+        console.log("\n🎉 RESUMO DAS SUAS ESCOLHAS:\n");
+        console.log("═══════════════════════════════════════");
+        console.log(`📝 Nome do Projeto: ${config.projectName}`);
+        console.log(`📦 Package Manager: ${config.packageManager}`);
+        console.log(`🏗️  Tipo de Aplicação: ${config.applicationType}`);
+        if (config.applicationType === "frontend") {
+            console.log(`⚡ Framework: ${config.framework}`);
+            console.log(`🌐 Cliente HTTP: ${config.httpClient}`);
+            console.log(`✨ Linter: ${config.linter}`);
+            if (config.additionalLibs && config.additionalLibs.length > 0) {
+                console.log(`📚 Libs Adicionais: ${config.additionalLibs.join(", ")}`);
+            }
+            else {
+                console.log("📚 Libs Adicionais: Nenhuma selecionada");
+            }
+            if (config.withShadcn) {
+                if (config.shadcnComponents && config.shadcnComponents.length > 0) {
+                    console.log(`🎨 shadcn/ui: Sim (${config.shadcnColor || "neutral"}, ${config.shadcnComponents.length} componente(s))`);
+                }
+                else {
+                    console.log(`🎨 shadcn/ui: Sim (${config.shadcnColor || "neutral"}, apenas init)`);
+                }
+            }
+            else {
+                console.log("🎨 shadcn/ui: Não");
+            }
+        }
+        // Git Setup
+        if (config.gitSetup && config.gitSetup !== "none") {
+            const setupLabel = config.gitSetup === "repo-and-deploy"
+                ? "Repo GitHub + Deploy Vercel"
+                : "Apenas Repo GitHub";
+            const repoFullName = config.repoOrg
+                ? `${config.repoOrg}/${config.repoName}`
+                : config.repoName;
+            console.log(`🚀 Git Setup: ${setupLabel}`);
+            console.log(`📦 Repositório: ${repoFullName} (${config.repoVisibility})`);
+        }
+        else {
+            console.log("🚀 Git Setup: Não configurado");
+        }
+        console.log("═══════════════════════════════════════\n");
+        await generateProject(config);
+    }
+    else {
+        // Modo interativo puro
+        console.clear();
+        intro("🚀 Bem-vindo ao Gerador de Projetos!");
+        const config = await runHybridMode({});
+        // Exibir resumo final
+        console.log("\n🎉 RESUMO DAS SUAS ESCOLHAS:\n");
+        console.log("═══════════════════════════════════════");
+        console.log(`📝 Nome do Projeto: ${config.projectName}`);
+        console.log(`📦 Package Manager: ${config.packageManager}`);
+        console.log(`🏗️  Tipo de Aplicação: ${config.applicationType}`);
+        if (config.applicationType === "frontend") {
+            console.log(`⚡ Framework: ${config.framework}`);
+            console.log(`🌐 Cliente HTTP: ${config.httpClient}`);
+            console.log(`✨ Linter: ${config.linter}`);
+            if (config.additionalLibs && config.additionalLibs.length > 0) {
+                console.log(`📚 Libs Adicionais: ${config.additionalLibs.join(", ")}`);
+            }
+            else {
+                console.log("📚 Libs Adicionais: Nenhuma selecionada");
+            }
+            if (config.withShadcn) {
+                if (config.shadcnComponents && config.shadcnComponents.length > 0) {
+                    console.log(`🎨 shadcn/ui: Sim (${config.shadcnColor || "neutral"}, ${config.shadcnComponents.length} componente(s))`);
+                }
+                else {
+                    console.log(`🎨 shadcn/ui: Sim (${config.shadcnColor || "neutral"}, apenas init)`);
+                }
+            }
+            else {
+                console.log("🎨 shadcn/ui: Não");
+            }
+        }
+        // Git Setup
+        if (config.gitSetup && config.gitSetup !== "none") {
+            const setupLabel = config.gitSetup === "repo-and-deploy"
+                ? "Repo GitHub + Deploy Vercel"
+                : "Apenas Repo GitHub";
+            const repoFullName = config.repoOrg
+                ? `${config.repoOrg}/${config.repoName}`
+                : config.repoName;
+            console.log(`🚀 Git Setup: ${setupLabel}`);
+            console.log(`📦 Repositório: ${repoFullName} (${config.repoVisibility})`);
+        }
+        else {
+            console.log("🚀 Git Setup: Não configurado");
+        }
+        console.log("═══════════════════════════════════════\n");
+        // Gerar o projeto
+        console.log("");
+        await generateProject(config);
+    }
+}
+main().catch(console.error);

package/dist/project-generator.d.ts

@@ -0,0 +1,15 @@
+import type { ProjectConfig } from "./types.js";
+export declare class ProjectGenerator {
+    private snippetManager;
+    private rootPath;
+    constructor(rootPath?: string);
+    generate(config: ProjectConfig): Promise<void>;
+    private copyTemplate;
+    private getTemplatePath;
+    private processSnippets;
+    private updatePackageJson;
+    private createEnvFile;
+    private installDependencies;
+    private setupShadcn;
+    private createVscodeConfig;
+}