@create-lft-app/cli 1.0.0

package/dist/bin/cli.js

@@ -0,0 +1,938 @@
+#!/usr/bin/env node
+
+// bin/cli.ts
+import { program } from "commander";
+
+// src/index.ts
+import path5 from "path";
+import { confirm as confirm2 } from "@inquirer/prompts";
+
+// src/config/index.ts
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+import { createCipheriv, createDecipheriv, randomBytes, createHash } from "crypto";
+import { machineIdSync } from "node-machine-id";
+import { input, password, select, confirm } from "@inquirer/prompts";
+
+// src/ui/logger.ts
+import chalk from "chalk";
+var logger = {
+  info: (message) => {
+    console.log(chalk.blue("\u2139"), message);
+  },
+  success: (message) => {
+    console.log(chalk.green("\u2714"), message);
+  },
+  warning: (message) => {
+    console.log(chalk.yellow("\u26A0"), message);
+  },
+  error: (message) => {
+    console.log(chalk.red("\u2716"), message);
+  },
+  step: (step, total, message) => {
+    console.log(chalk.cyan(`[${step}/${total}]`), message);
+  },
+  newLine: () => {
+    console.log();
+  },
+  divider: () => {
+    console.log(chalk.gray("\u2500".repeat(50)));
+  },
+  title: (message) => {
+    console.log(chalk.bold.white(message));
+  },
+  subtitle: (message) => {
+    console.log(chalk.gray(message));
+  },
+  link: (label, url) => {
+    console.log(`  ${chalk.gray(label + ":")} ${chalk.cyan.underline(url)}`);
+  },
+  list: (items) => {
+    items.forEach((item) => {
+      console.log(chalk.gray("  \u2022"), item);
+    });
+  },
+  table: (rows) => {
+    const maxLabelLength = Math.max(...rows.map((r) => r.label.length));
+    rows.forEach(({ label, value }) => {
+      const paddedLabel = label.padEnd(maxLabelLength);
+      console.log(`  ${chalk.gray(paddedLabel)}  ${value}`);
+    });
+  }
+};
+
+// src/ui/spinner.ts
+import ora from "ora";
+function createSpinner(text) {
+  return ora({
+    text,
+    spinner: "dots"
+  });
+}
+async function withSpinner(text, fn, successText) {
+  const spinner = createSpinner(text).start();
+  try {
+    const result = await fn();
+    spinner.succeed(successText || text);
+    return result;
+  } catch (error) {
+    spinner.fail();
+    throw error;
+  }
+}
+
+// src/config/index.ts
+var CONFIG_FILE = path.join(os.homedir(), ".lftrc");
+var ALGORITHM = "aes-256-gcm";
+function getEncryptionKey() {
+  const machineId = machineIdSync();
+  return createHash("sha256").update(machineId + "lft-secret").digest();
+}
+function encryptConfig(config) {
+  const key = getEncryptionKey();
+  const iv = randomBytes(16);
+  const cipher = createCipheriv(ALGORITHM, key, iv);
+  let encrypted = cipher.update(JSON.stringify(config), "utf8", "hex");
+  encrypted += cipher.final("hex");
+  const authTag = cipher.getAuthTag();
+  return JSON.stringify({
+    iv: iv.toString("hex"),
+    tag: authTag.toString("hex"),
+    data: encrypted
+  });
+}
+function decryptConfig(encrypted) {
+  const { iv, tag, data } = JSON.parse(encrypted);
+  const key = getEncryptionKey();
+  const decipher = createDecipheriv(ALGORITHM, key, Buffer.from(iv, "hex"));
+  decipher.setAuthTag(Buffer.from(tag, "hex"));
+  let decrypted = decipher.update(data, "hex", "utf8");
+  decrypted += decipher.final("utf8");
+  return JSON.parse(decrypted);
+}
+async function hasConfig() {
+  try {
+    await fs.access(CONFIG_FILE);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadConfig() {
+  const encrypted = await fs.readFile(CONFIG_FILE, "utf8");
+  return decryptConfig(encrypted);
+}
+async function saveConfig(config) {
+  const encrypted = encryptConfig(config);
+  await fs.writeFile(CONFIG_FILE, encrypted, "utf8");
+}
+async function showConfig() {
+  if (!await hasConfig()) {
+    logger.warning("No hay configuraci\xF3n guardada");
+    logger.info('Ejecuta "create-lft-app config" para configurar');
+    return;
+  }
+  const config = await loadConfig();
+  logger.newLine();
+  logger.title("Configuraci\xF3n actual:");
+  logger.newLine();
+  logger.subtitle("GitHub:");
+  logger.table([
+    { label: "Usuario", value: config.credentials.github.username },
+    { label: "Token", value: "***" + config.credentials.github.token.slice(-4) },
+    { label: "Org por defecto", value: config.defaults.githubOrg || "(ninguna)" }
+  ]);
+  logger.newLine();
+  logger.subtitle("Supabase:");
+  logger.table([
+    { label: "Org ID", value: config.credentials.supabase.organizationId },
+    { label: "Token", value: "***" + config.credentials.supabase.accessToken.slice(-4) },
+    { label: "Regi\xF3n", value: config.defaults.supabaseRegion }
+  ]);
+  logger.newLine();
+  logger.subtitle("Jira:");
+  logger.table([
+    { label: "Email", value: config.credentials.jira.email },
+    { label: "Dominio", value: config.credentials.jira.domain },
+    { label: "Token", value: "***" + config.credentials.jira.apiToken.slice(-4) }
+  ]);
+}
+async function resetConfig() {
+  if (!await hasConfig()) {
+    logger.info("No hay configuraci\xF3n para resetear");
+    return;
+  }
+  const shouldReset = await confirm({
+    message: "\xBFEst\xE1s seguro de que quieres eliminar la configuraci\xF3n?",
+    default: false
+  });
+  if (shouldReset) {
+    await fs.unlink(CONFIG_FILE);
+    logger.success("Configuraci\xF3n eliminada");
+  }
+}
+async function configureCredentials(options = {}) {
+  let config;
+  if (await hasConfig()) {
+    config = await loadConfig();
+    logger.info("Configuraci\xF3n existente encontrada. Actualizando...");
+  } else {
+    config = {
+      version: "1.0.0",
+      credentials: {
+        github: { token: "", username: "" },
+        supabase: { accessToken: "", organizationId: "" },
+        jira: { email: "", apiToken: "", domain: "" }
+      },
+      defaults: {
+        supabaseRegion: "us-east-1",
+        jiraProjectType: "software"
+      }
+    };
+  }
+  const configureAll = !options.onlyGithub && !options.onlySupabase && !options.onlyJira;
+  if (configureAll || options.onlyGithub) {
+    logger.newLine();
+    logger.title("Configuraci\xF3n de GitHub");
+    logger.subtitle("Necesitas un Personal Access Token con permisos: repo, read:org");
+    logger.link("Crear token", "https://github.com/settings/tokens/new");
+    logger.newLine();
+    const githubToken = await password({
+      message: "GitHub Personal Access Token:",
+      mask: "*"
+    });
+    const isValid = await withSpinner(
+      "Validando token de GitHub...",
+      async () => {
+        const response = await fetch("https://api.github.com/user", {
+          headers: { Authorization: `Bearer ${githubToken}` }
+        });
+        if (!response.ok) return null;
+        return response.json();
+      }
+    );
+    if (!isValid) {
+      throw new Error("Token de GitHub inv\xE1lido");
+    }
+    config.credentials.github.token = githubToken;
+    config.credentials.github.username = isValid.login;
+    logger.success(`Conectado como: ${isValid.login}`);
+    const useOrg = await confirm({
+      message: "\xBFQuieres usar una organizaci\xF3n por defecto?",
+      default: false
+    });
+    if (useOrg) {
+      config.defaults.githubOrg = await input({
+        message: "Nombre de la organizaci\xF3n:"
+      });
+    }
+  }
+  if (configureAll || options.onlySupabase) {
+    logger.newLine();
+    logger.title("Configuraci\xF3n de Supabase");
+    logger.subtitle("Necesitas un Access Token de la Management API");
+    logger.link("Crear token", "https://supabase.com/dashboard/account/tokens");
+    logger.newLine();
+    const supabaseToken = await password({
+      message: "Supabase Access Token:",
+      mask: "*"
+    });
+    const orgs = await withSpinner(
+      "Obteniendo organizaciones de Supabase...",
+      async () => {
+        const response = await fetch("https://api.supabase.com/v1/organizations", {
+          headers: { Authorization: `Bearer ${supabaseToken}` }
+        });
+        if (!response.ok) return null;
+        return response.json();
+      }
+    );
+    if (!orgs || orgs.length === 0) {
+      throw new Error("Token de Supabase inv\xE1lido o no tienes organizaciones");
+    }
+    config.credentials.supabase.accessToken = supabaseToken;
+    if (orgs.length === 1) {
+      config.credentials.supabase.organizationId = orgs[0].id;
+      logger.success(`Usando organizaci\xF3n: ${orgs[0].name}`);
+    } else {
+      const selectedOrg = await select({
+        message: "Selecciona la organizaci\xF3n:",
+        choices: orgs.map((org) => ({ name: org.name, value: org.id }))
+      });
+      config.credentials.supabase.organizationId = selectedOrg;
+    }
+    config.defaults.supabaseRegion = await select({
+      message: "Regi\xF3n por defecto:",
+      choices: [
+        { name: "US East (Virginia)", value: "us-east-1" },
+        { name: "US West (Oregon)", value: "us-west-1" },
+        { name: "EU West (Ireland)", value: "eu-west-1" },
+        { name: "AP Southeast (Singapore)", value: "ap-southeast-1" },
+        { name: "AP Northeast (Tokyo)", value: "ap-northeast-1" },
+        { name: "SA East (S\xE3o Paulo)", value: "sa-east-1" }
+      ],
+      default: "us-east-1"
+    });
+  }
+  if (configureAll || options.onlyJira) {
+    logger.newLine();
+    logger.title("Configuraci\xF3n de Jira");
+    logger.subtitle("Necesitas un API Token de Atlassian");
+    logger.link("Crear token", "https://id.atlassian.com/manage-profile/security/api-tokens");
+    logger.newLine();
+    const jiraEmail = await input({
+      message: "Email de Atlassian:"
+    });
+    const jiraToken = await password({
+      message: "Jira API Token:",
+      mask: "*"
+    });
+    const jiraDomain = await input({
+      message: "Dominio de Jira (ej: empresa.atlassian.net):",
+      validate: (value) => {
+        if (!value.includes(".atlassian.net")) {
+          return "El dominio debe terminar en .atlassian.net";
+        }
+        return true;
+      }
+    });
+    const isValid = await withSpinner(
+      "Validando credenciales de Jira...",
+      async () => {
+        const auth = Buffer.from(`${jiraEmail}:${jiraToken}`).toString("base64");
+        const response = await fetch(`https://${jiraDomain}/rest/api/3/myself`, {
+          headers: { Authorization: `Basic ${auth}` }
+        });
+        return response.ok;
+      }
+    );
+    if (!isValid) {
+      throw new Error("Credenciales de Jira inv\xE1lidas");
+    }
+    config.credentials.jira.email = jiraEmail;
+    config.credentials.jira.apiToken = jiraToken;
+    config.credentials.jira.domain = jiraDomain;
+    logger.success("Credenciales de Jira v\xE1lidas");
+  }
+  await saveConfig(config);
+  logger.newLine();
+  logger.success("Configuraci\xF3n guardada en ~/.lftrc");
+}
+
+// src/services/github.ts
+import { Octokit } from "octokit";
+async function createGitHubRepo(projectName, config) {
+  const octokit = new Octokit({ auth: config.credentials.github.token });
+  const org = config.defaults.githubOrg;
+  return withSpinner(
+    "Creando repositorio en GitHub...",
+    async () => {
+      let repo;
+      if (org) {
+        repo = await octokit.rest.repos.createInOrg({
+          org,
+          name: projectName,
+          private: true,
+          auto_init: false,
+          description: `Proyecto ${projectName} creado con create-lft-app`
+        });
+      } else {
+        repo = await octokit.rest.repos.createForAuthenticatedUser({
+          name: projectName,
+          private: true,
+          auto_init: false,
+          description: `Proyecto ${projectName} creado con create-lft-app`
+        });
+      }
+      return repo.data.html_url;
+    },
+    `Repositorio creado: ${org || config.credentials.github.username}/${projectName}`
+  );
+}
+
+// src/services/supabase.ts
+var SUPABASE_API_URL = "https://api.supabase.com/v1";
+async function waitForProjectReady(projectId, token, maxAttempts = 60) {
+  const spinner = createSpinner("Provisionando base de datos (esto puede tomar ~2 minutos)...").start();
+  for (let i = 0; i < maxAttempts; i++) {
+    const response = await fetch(`${SUPABASE_API_URL}/projects/${projectId}`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (response.ok) {
+      const project = await response.json();
+      if (project.status === "ACTIVE_HEALTHY") {
+        spinner.succeed("Base de datos provisionada");
+        return;
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, 5e3));
+    spinner.text = `Provisionando base de datos... (${Math.floor((i + 1) * 5 / 60)}min ${(i + 1) * 5 % 60}s)`;
+  }
+  spinner.fail("Timeout esperando a que el proyecto est\xE9 listo");
+  throw new Error("Timeout: el proyecto de Supabase no se activ\xF3 a tiempo");
+}
+async function getProjectApiKeys(projectId, token) {
+  const response = await fetch(`${SUPABASE_API_URL}/projects/${projectId}/api-keys`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!response.ok) {
+    throw new Error("No se pudieron obtener las API keys de Supabase");
+  }
+  const keys = await response.json();
+  const anonKey = keys.find((k) => k.name === "anon")?.api_key;
+  const serviceKey = keys.find((k) => k.name === "service_role")?.api_key;
+  if (!anonKey || !serviceKey) {
+    throw new Error("No se encontraron las API keys necesarias");
+  }
+  return { anonKey, serviceKey };
+}
+async function createSupabaseProject(projectName, config) {
+  const token = config.credentials.supabase.accessToken;
+  const orgId = config.credentials.supabase.organizationId;
+  const region = config.defaults.supabaseRegion;
+  const dbPassword = generateSecurePassword();
+  const project = await withSpinner(
+    "Creando proyecto en Supabase...",
+    async () => {
+      const response = await fetch(`${SUPABASE_API_URL}/projects`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          name: projectName,
+          organization_id: orgId,
+          region,
+          plan: "free",
+          db_pass: dbPassword
+        })
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Error creando proyecto Supabase: ${error}`);
+      }
+      return response.json();
+    }
+  );
+  await waitForProjectReady(project.id, token);
+  const { anonKey, serviceKey } = await getProjectApiKeys(project.id, token);
+  const projectUrl = `https://${project.id}.supabase.co`;
+  return {
+    url: projectUrl,
+    anonKey,
+    serviceKey
+  };
+}
+function generateSecurePassword() {
+  const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*";
+  let password2 = "";
+  for (let i = 0; i < 32; i++) {
+    password2 += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return password2;
+}
+
+// src/utils/validation.ts
+import fs2 from "fs";
+import path2 from "path";
+function validateProjectName(name) {
+  if (!name || name.trim() === "") {
+    return { valid: false, error: "El nombre del proyecto no puede estar vac\xEDo" };
+  }
+  const validPattern = /^[a-zA-Z0-9_-]+$/;
+  if (!validPattern.test(name)) {
+    return {
+      valid: false,
+      error: "El nombre solo puede contener letras, n\xFAmeros, guiones (-) y guiones bajos (_)"
+    };
+  }
+  if (/^[-_0-9]/.test(name)) {
+    return {
+      valid: false,
+      error: "El nombre debe empezar con una letra"
+    };
+  }
+  if (name.length < 2) {
+    return { valid: false, error: "El nombre debe tener al menos 2 caracteres" };
+  }
+  if (name.length > 50) {
+    return { valid: false, error: "El nombre no puede tener m\xE1s de 50 caracteres" };
+  }
+  const projectPath = path2.resolve(process.cwd(), name);
+  if (fs2.existsSync(projectPath)) {
+    return { valid: false, error: `El directorio "${name}" ya existe` };
+  }
+  return { valid: true };
+}
+function generateJiraKey(projectName) {
+  const cleaned = projectName.replace(/[^a-zA-Z0-9]/g, "").toUpperCase().slice(0, 10);
+  return cleaned || "PROJ";
+}
+
+// src/services/jira.ts
+async function createJiraProject(projectName, config) {
+  const { email, apiToken, domain } = config.credentials.jira;
+  const auth = Buffer.from(`${email}:${apiToken}`).toString("base64");
+  const projectKey = generateJiraKey(projectName);
+  return withSpinner(
+    "Creando proyecto en Jira...",
+    async () => {
+      const meResponse = await fetch(`https://${domain}/rest/api/3/myself`, {
+        headers: {
+          Authorization: `Basic ${auth}`,
+          "Content-Type": "application/json"
+        }
+      });
+      if (!meResponse.ok) {
+        throw new Error("No se pudo obtener informaci\xF3n del usuario de Jira");
+      }
+      const me = await meResponse.json();
+      const response = await fetch(`https://${domain}/rest/api/3/project`, {
+        method: "POST",
+        headers: {
+          Authorization: `Basic ${auth}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          key: projectKey,
+          name: projectName,
+          projectTypeKey: "software",
+          projectTemplateKey: "com.pyxis.greenhopper.jira:gh-simplified-agility-scrum",
+          leadAccountId: me.accountId
+        })
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        if (error.includes("project key")) {
+          const newKey = `${projectKey}${Date.now().toString().slice(-4)}`;
+          const retryResponse = await fetch(`https://${domain}/rest/api/3/project`, {
+            method: "POST",
+            headers: {
+              Authorization: `Basic ${auth}`,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              key: newKey,
+              name: projectName,
+              projectTypeKey: "software",
+              projectTemplateKey: "com.pyxis.greenhopper.jira:gh-simplified-agility-scrum",
+              leadAccountId: me.accountId
+            })
+          });
+          if (!retryResponse.ok) {
+            throw new Error(`Error creando proyecto Jira: ${await retryResponse.text()}`);
+          }
+          const project2 = await retryResponse.json();
+          return `https://${domain}/browse/${project2.key}`;
+        }
+        throw new Error(`Error creando proyecto Jira: ${error}`);
+      }
+      const project = await response.json();
+      return `https://${domain}/browse/${project.key}`;
+    },
+    `Proyecto Jira creado: ${projectKey}`
+  );
+}
+
+// src/steps/scaffold-nextjs.ts
+import { execa } from "execa";
+async function scaffoldNextJs(projectName, projectPath) {
+  await withSpinner(
+    "Inicializando proyecto Next.js...",
+    async () => {
+      await execa("npx", [
+        "create-next-app@latest",
+        projectName,
+        "--typescript",
+        "--tailwind",
+        "--eslint",
+        "--app",
+        "--turbopack",
+        "--src-dir",
+        "--import-alias",
+        "@/*",
+        "--use-npm"
+      ], {
+        cwd: process.cwd(),
+        stdio: "pipe"
+      });
+    },
+    "Proyecto Next.js inicializado"
+  );
+}
+
+// src/steps/copy-template.ts
+import { cp, mkdir, readFile, writeFile } from "fs/promises";
+import path3 from "path";
+import { fileURLToPath } from "url";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path3.dirname(__filename2);
+async function copyTemplate(projectPath) {
+  await withSpinner(
+    "Copiando template LFT...",
+    async () => {
+      const templatesDir = path3.join(__dirname2, "..", "..", "templates");
+      const srcDir = path3.join(projectPath, "src");
+      await cp(
+        path3.join(templatesDir, "components", "ui"),
+        path3.join(srcDir, "components", "ui"),
+        { recursive: true }
+      );
+      await cp(
+        path3.join(templatesDir, "components", "layout"),
+        path3.join(srcDir, "components", "layout"),
+        { recursive: true }
+      );
+      await cp(
+        path3.join(templatesDir, "components", "dashboard"),
+        path3.join(srcDir, "components", "dashboard"),
+        { recursive: true }
+      );
+      await mkdir(path3.join(srcDir, "lib"), { recursive: true });
+      await cp(
+        path3.join(templatesDir, "lib", "utils.ts"),
+        path3.join(srcDir, "lib", "utils.ts")
+      );
+      await mkdir(path3.join(srcDir, "hooks"), { recursive: true });
+      await cp(
+        path3.join(templatesDir, "hooks"),
+        path3.join(srcDir, "hooks"),
+        { recursive: true }
+      );
+      await cp(
+        path3.join(templatesDir, "app", "layout.tsx"),
+        path3.join(srcDir, "app", "layout.tsx")
+      );
+      await cp(
+        path3.join(templatesDir, "app", "page.tsx"),
+        path3.join(srcDir, "app", "page.tsx")
+      );
+      await mkdir(path3.join(srcDir, "app", "dashboard"), { recursive: true });
+      await cp(
+        path3.join(templatesDir, "app", "dashboard", "page.tsx"),
+        path3.join(srcDir, "app", "dashboard", "page.tsx")
+      );
+      await mkdir(path3.join(srcDir, "app", "auth", "login"), { recursive: true });
+      await cp(
+        path3.join(templatesDir, "app", "auth", "login", "page.tsx"),
+        path3.join(srcDir, "app", "auth", "login", "page.tsx")
+      );
+      await mergeGlobalStyles(projectPath, templatesDir);
+    },
+    "Template LFT copiado (47 componentes + p\xE1ginas)"
+  );
+}
+async function mergeGlobalStyles(projectPath, templatesDir) {
+  const templateCssPath = path3.join(templatesDir, "app", "globals.css");
+  const projectCssPath = path3.join(projectPath, "src", "app", "globals.css");
+  try {
+    const templateCss = await readFile(templateCssPath, "utf-8");
+    const existingCss = await readFile(projectCssPath, "utf-8");
+    const merged = existingCss + "\n\n/* LFT Custom Styles */\n" + templateCss;
+    await writeFile(projectCssPath, merged);
+  } catch {
+  }
+}
+
+// src/steps/install-deps.ts
+import { execa as execa2 } from "execa";
+var TEMPLATE_DEPENDENCIES = [
+  // Radix UI primitives
+  "@radix-ui/react-accordion",
+  "@radix-ui/react-alert-dialog",
+  "@radix-ui/react-avatar",
+  "@radix-ui/react-checkbox",
+  "@radix-ui/react-collapsible",
+  "@radix-ui/react-dialog",
+  "@radix-ui/react-dropdown-menu",
+  "@radix-ui/react-label",
+  "@radix-ui/react-popover",
+  "@radix-ui/react-progress",
+  "@radix-ui/react-radio-group",
+  "@radix-ui/react-scroll-area",
+  "@radix-ui/react-select",
+  "@radix-ui/react-separator",
+  "@radix-ui/react-slider",
+  "@radix-ui/react-slot",
+  "@radix-ui/react-switch",
+  "@radix-ui/react-tabs",
+  "@radix-ui/react-tooltip",
+  // UI Utilities
+  "class-variance-authority",
+  "clsx",
+  "tailwind-merge",
+  // Icons
+  "lucide-react",
+  // Form handling
+  "react-hook-form",
+  "@hookform/resolvers",
+  // Command menu
+  "cmdk",
+  // Date picker
+  "react-day-picker",
+  "date-fns",
+  // Toast notifications
+  "sonner",
+  // Validation
+  "zod",
+  // Supabase client
+  "@supabase/supabase-js",
+  "@supabase/ssr"
+];
+var TEMPLATE_DEV_DEPENDENCIES = [
+  "tailwindcss-animate"
+];
+async function installDependencies(projectPath) {
+  await withSpinner(
+    `Instalando dependencias (${TEMPLATE_DEPENDENCIES.length} paquetes)...`,
+    async () => {
+      await execa2("npm", ["install", ...TEMPLATE_DEPENDENCIES], {
+        cwd: projectPath,
+        stdio: "pipe"
+      });
+      await execa2("npm", ["install", "-D", ...TEMPLATE_DEV_DEPENDENCIES], {
+        cwd: projectPath,
+        stdio: "pipe"
+      });
+    },
+    "Dependencias instaladas"
+  );
+}
+
+// src/steps/create-env.ts
+import { writeFile as writeFile2, readFile as readFile2, appendFile } from "fs/promises";
+import path4 from "path";
+async function createEnvFile(projectPath, supabaseKeys) {
+  await withSpinner(
+    "Creando archivo .env.local...",
+    async () => {
+      const envContent = `# Supabase
+NEXT_PUBLIC_SUPABASE_URL=${supabaseKeys.url}
+NEXT_PUBLIC_SUPABASE_ANON_KEY=${supabaseKeys.anonKey}
+SUPABASE_SERVICE_ROLE_KEY=${supabaseKeys.serviceKey}
+`;
+      await writeFile2(
+        path4.join(projectPath, ".env.local"),
+        envContent
+      );
+      const gitignorePath = path4.join(projectPath, ".gitignore");
+      try {
+        const gitignore = await readFile2(gitignorePath, "utf-8");
+        if (!gitignore.includes(".env.local")) {
+          await appendFile(gitignorePath, "\n# Environment variables\n.env.local\n.env*.local\n");
+        }
+      } catch {
+        await writeFile2(gitignorePath, "# Environment variables\n.env.local\n.env*.local\n");
+      }
+    },
+    "Archivo .env.local creado con credenciales de Supabase"
+  );
+}
+
+// src/steps/setup-git.ts
+import { simpleGit } from "simple-git";
+async function setupGit(projectPath, remoteUrl) {
+  const git = simpleGit(projectPath);
+  await withSpinner(
+    "Configurando Git...",
+    async () => {
+      const isRepo = await git.checkIsRepo();
+      if (!isRepo) {
+        await git.init();
+      }
+      try {
+        await git.addRemote("origin", remoteUrl);
+      } catch {
+        await git.remote(["set-url", "origin", remoteUrl]);
+      }
+      await git.add(".");
+      await git.commit("Initial commit - created with create-lft-app", {
+        "--author": "create-lft-app <noreply@lft.dev>"
+      });
+      try {
+        await git.branch(["-M", "main"]);
+      } catch {
+      }
+      await git.push(["--set-upstream", "origin", "main"]);
+    },
+    "Git configurado y c\xF3digo pusheado"
+  );
+}
+
+// src/ui/banner.ts
+import boxen from "boxen";
+import chalk2 from "chalk";
+function showBanner() {
+  const title = chalk2.bold.cyan("create-lft-app");
+  const version = chalk2.gray("v1.0.0");
+  const description = chalk2.white("Scaffolding para proyectos LFT");
+  const banner = boxen(`${title} ${version}
+${description}`, {
+    padding: 1,
+    margin: 1,
+    borderStyle: "round",
+    borderColor: "cyan"
+  });
+  console.log(banner);
+}
+function showSuccessBanner(projectName, urls) {
+  const lines = [
+    chalk2.green.bold(`Proyecto "${projectName}" creado exitosamente!`),
+    "",
+    chalk2.white("Directorio:") + ` ./${projectName}`,
+    ""
+  ];
+  if (urls.github || urls.supabase || urls.jira) {
+    lines.push(chalk2.white("Enlaces:"));
+    if (urls.github) {
+      lines.push(`  ${chalk2.gray("GitHub:")}   ${chalk2.cyan(urls.github)}`);
+    }
+    if (urls.supabase) {
+      lines.push(`  ${chalk2.gray("Supabase:")} ${chalk2.cyan(urls.supabase)}`);
+    }
+    if (urls.jira) {
+      lines.push(`  ${chalk2.gray("Jira:")}     ${chalk2.cyan(urls.jira)}`);
+    }
+    lines.push("");
+  }
+  lines.push(chalk2.white("Siguiente pasos:"));
+  lines.push(`  ${chalk2.cyan("cd")} ${projectName}`);
+  lines.push(`  ${chalk2.cyan("npm run dev")}`);
+  const banner = boxen(lines.join("\n"), {
+    padding: 1,
+    margin: 1,
+    borderStyle: "round",
+    borderColor: "green"
+  });
+  console.log(banner);
+}
+
+// src/index.ts
+async function createProject(projectName, options = {}) {
+  const validation = validateProjectName(projectName);
+  if (!validation.valid) {
+    throw new Error(validation.error);
+  }
+  const projectPath = path5.resolve(process.cwd(), projectName);
+  if (!await hasConfig()) {
+    logger.warning('No se encontr\xF3 configuraci\xF3n. Ejecuta "create-lft-app config" primero.');
+    throw new Error("Configuraci\xF3n no encontrada");
+  }
+  const config = await loadConfig();
+  logger.newLine();
+  logger.title("Resumen de recursos a crear:");
+  logger.newLine();
+  const resources = [];
+  if (!options.skipGithub) {
+    resources.push({ label: "GitHub", value: `${config.defaults.githubOrg || config.credentials.github.username}/${projectName} (privado)` });
+  }
+  if (!options.skipSupabase) {
+    resources.push({ label: "Supabase", value: `${projectName} en ${config.defaults.supabaseRegion}` });
+  }
+  if (!options.skipJira) {
+    resources.push({ label: "Jira", value: `Proyecto "${projectName}" en ${config.credentials.jira.domain}` });
+  }
+  resources.push({ label: "Next.js", value: "App Router + TypeScript + Tailwind + Dashboard" });
+  logger.table(resources);
+  logger.newLine();
+  if (!options.autoConfirm) {
+    const shouldContinue = await confirm2({
+      message: "\xBFContinuar con la creaci\xF3n?",
+      default: true
+    });
+    if (!shouldContinue) {
+      logger.info("Operaci\xF3n cancelada");
+      return;
+    }
+  }
+  logger.newLine();
+  logger.divider();
+  logger.newLine();
+  const urls = {};
+  let supabaseKeys;
+  const externalTasks = [];
+  if (!options.skipGithub) {
+    externalTasks.push(
+      createGitHubRepo(projectName, config).then((url) => {
+        urls.github = url;
+      })
+    );
+  }
+  if (!options.skipSupabase) {
+    externalTasks.push(
+      createSupabaseProject(projectName, config).then((result) => {
+        urls.supabase = result.url;
+        supabaseKeys = result;
+      })
+    );
+  }
+  if (!options.skipJira) {
+    externalTasks.push(
+      createJiraProject(projectName, config).then((url) => {
+        urls.jira = url;
+      })
+    );
+  }
+  await Promise.all(externalTasks);
+  await scaffoldNextJs(projectName, projectPath);
+  await copyTemplate(projectPath);
+  await installDependencies(projectPath);
+  if (supabaseKeys) {
+    await createEnvFile(projectPath, supabaseKeys);
+  }
+  if (!options.skipGit && urls.github) {
+    await setupGit(projectPath, urls.github);
+  }
+  logger.newLine();
+  showSuccessBanner(projectName, urls);
+}
+
+// bin/cli.ts
+var packageJson = {
+  name: "create-lft-app",
+  version: "1.0.0",
+  description: "CLI para crear proyectos LFT con Next.js, GitHub, Supabase y Jira"
+};
+program.name("create-lft-app").description(packageJson.description).version(packageJson.version);
+program.argument("[project-name]", "Nombre del proyecto a crear").option("--skip-github", "No crear repositorio en GitHub").option("--skip-supabase", "No crear proyecto en Supabase").option("--skip-jira", "No crear workspace en Jira").option("--skip-git", "No inicializar git ni hacer push").option("-y, --yes", "Aceptar todas las confirmaciones").action(async (projectName, options) => {
+  showBanner();
+  if (!projectName) {
+    logger.error("Debes especificar un nombre de proyecto");
+    logger.info("Uso: create-lft-app <nombre-proyecto>");
+    process.exit(1);
+  }
+  try {
+    await createProject(projectName, {
+      skipGithub: options.skipGithub,
+      skipSupabase: options.skipSupabase,
+      skipJira: options.skipJira,
+      skipGit: options.skipGit,
+      autoConfirm: options.yes
+    });
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error(error.message);
+    }
+    process.exit(1);
+  }
+});
+program.command("config").description("Configurar credenciales de APIs").option("--show", "Mostrar configuraci\xF3n actual").option("--reset", "Resetear configuraci\xF3n").option("--github", "Configurar solo GitHub").option("--supabase", "Configurar solo Supabase").option("--jira", "Configurar solo Jira").action(async (options) => {
+  showBanner();
+  if (options.show) {
+    await showConfig();
+    return;
+  }
+  if (options.reset) {
+    await resetConfig();
+    return;
+  }
+  await configureCredentials({
+    onlyGithub: options.github,
+    onlySupabase: options.supabase,
+    onlyJira: options.jira
+  });
+});
+program.parse();
+//# sourceMappingURL=cli.js.map