@create-lft-app/cli 1.0.2 → 1.0.3

package/dist/src/index.js

@@ -1,170 +1,82 @@
 #!/usr/bin/env node
 
 // 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 nodeMachineId from "node-machine-id";
-import { input, password, select, confirm } from "@inquirer/prompts";
+import path4 from "path";
+import { 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();
+// src/config/static-config.ts
+var STATIC_CONFIG = {
+  github: {
+    token: "__GITHUB_TOKEN__",
+    username: "__GITHUB_USERNAME__",
+    org: "__GITHUB_ORG__"
   },
-  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);
-    });
+  supabase: {
+    token: "__SUPABASE_TOKEN__",
+    orgId: "__SUPABASE_ORG_ID__",
+    region: "us-east-1"
   },
-  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}`);
-    });
+  jira: {
+    email: "__JIRA_EMAIL__",
+    token: "__JIRA_TOKEN__",
+    domain: "__JIRA_DOMAIN__"
   }
 };
 
-// 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 { machineIdSync } = nodeMachineId;
-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 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);
-}
-var ENV_VARS = {
-  GITHUB_TOKEN: "LFT_GITHUB_TOKEN",
-  GITHUB_USERNAME: "LFT_GITHUB_USERNAME",
-  GITHUB_ORG: "LFT_GITHUB_ORG",
-  SUPABASE_TOKEN: "LFT_SUPABASE_TOKEN",
-  SUPABASE_ORG_ID: "LFT_SUPABASE_ORG_ID",
-  SUPABASE_REGION: "LFT_SUPABASE_REGION",
-  JIRA_EMAIL: "LFT_JIRA_EMAIL",
-  JIRA_TOKEN: "LFT_JIRA_TOKEN",
-  JIRA_DOMAIN: "LFT_JIRA_DOMAIN"
-};
-function loadConfigFromEnv() {
-  const githubToken = process.env[ENV_VARS.GITHUB_TOKEN];
-  const githubUsername = process.env[ENV_VARS.GITHUB_USERNAME];
-  const supabaseToken = process.env[ENV_VARS.SUPABASE_TOKEN];
-  const supabaseOrgId = process.env[ENV_VARS.SUPABASE_ORG_ID];
-  const jiraEmail = process.env[ENV_VARS.JIRA_EMAIL];
-  const jiraToken = process.env[ENV_VARS.JIRA_TOKEN];
-  const jiraDomain = process.env[ENV_VARS.JIRA_DOMAIN];
-  if (!githubToken || !supabaseToken || !jiraToken) {
-    return null;
-  }
+async function loadConfig() {
   return {
     version: "1.0.0",
     credentials: {
       github: {
-        token: githubToken,
-        username: githubUsername || ""
+        token: STATIC_CONFIG.github.token,
+        username: STATIC_CONFIG.github.username
       },
       supabase: {
-        accessToken: supabaseToken,
-        organizationId: supabaseOrgId || ""
+        accessToken: STATIC_CONFIG.supabase.token,
+        organizationId: STATIC_CONFIG.supabase.orgId
       },
       jira: {
-        email: jiraEmail || "",
-        apiToken: jiraToken,
-        domain: jiraDomain || ""
+        email: STATIC_CONFIG.jira.email,
+        apiToken: STATIC_CONFIG.jira.token,
+        domain: STATIC_CONFIG.jira.domain
       }
     },
     defaults: {
-      githubOrg: process.env[ENV_VARS.GITHUB_ORG],
-      supabaseRegion: process.env[ENV_VARS.SUPABASE_REGION] || "us-east-1",
+      githubOrg: STATIC_CONFIG.github.org || void 0,
+      supabaseRegion: STATIC_CONFIG.supabase.region,
       jiraProjectType: "software"
     }
   };
 }
-function hasEnvConfig() {
-  return !!(process.env[ENV_VARS.GITHUB_TOKEN] && process.env[ENV_VARS.SUPABASE_TOKEN] && process.env[ENV_VARS.JIRA_TOKEN]);
-}
 async function hasConfig() {
-  if (hasEnvConfig()) return true;
-  try {
-    await fs.access(CONFIG_FILE);
-    return true;
-  } catch {
-    return false;
-  }
+  return STATIC_CONFIG.github.token !== "__GITHUB_TOKEN__" && STATIC_CONFIG.supabase.token !== "__SUPABASE_TOKEN__" && STATIC_CONFIG.jira.token !== "__JIRA_TOKEN__";
 }
-async function loadConfig() {
-  const envConfig = loadConfigFromEnv();
-  if (envConfig) {
-    return envConfig;
+
+// src/services/github.ts
+import { Octokit } from "octokit";
+
+// 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;
   }
-  const encrypted = await fs.readFile(CONFIG_FILE, "utf8");
-  return decryptConfig(encrypted);
 }
 
 // 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;
@@ -270,16 +182,16 @@ async function createSupabaseProject(projectName, config) {
 }
 function generateSecurePassword() {
   const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*";
-  let password2 = "";
+  let password = "";
   for (let i = 0; i < 32; i++) {
-    password2 += chars.charAt(Math.floor(Math.random() * chars.length));
+    password += chars.charAt(Math.floor(Math.random() * chars.length));
   }
-  return password2;
+  return password;
 }
 
 // src/utils/validation.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs from "fs";
+import path from "path";
 function validateProjectName(name) {
   if (!name || name.trim() === "") {
     return { valid: false, error: "El nombre del proyecto no puede estar vac\xEDo" };
@@ -303,8 +215,8 @@ function validateProjectName(name) {
   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)) {
+  const projectPath = path.resolve(process.cwd(), name);
+  if (fs.existsSync(projectPath)) {
     return { valid: false, error: `El directorio "${name}" ya existe` };
   }
   return { valid: true };
@@ -408,59 +320,59 @@ async function scaffoldNextJs(projectName, projectPath) {
 
 // src/steps/copy-template.ts
 import { cp, mkdir, readFile, writeFile } from "fs/promises";
-import path3 from "path";
+import path2 from "path";
 import { fileURLToPath } from "url";
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path3.dirname(__filename2);
+var __dirname2 = path2.dirname(__filename2);
 async function copyTemplate(projectPath) {
   await withSpinner(
     "Copiando template LFT...",
     async () => {
-      const templatesDir = path3.join(__dirname2, "..", "..", "templates");
-      const srcDir = path3.join(projectPath, "src");
+      const templatesDir = path2.join(__dirname2, "..", "..", "templates");
+      const srcDir = path2.join(projectPath, "src");
       await cp(
-        path3.join(templatesDir, "components", "ui"),
-        path3.join(srcDir, "components", "ui"),
+        path2.join(templatesDir, "components", "ui"),
+        path2.join(srcDir, "components", "ui"),
         { recursive: true }
       );
       await cp(
-        path3.join(templatesDir, "components", "layout"),
-        path3.join(srcDir, "components", "layout"),
+        path2.join(templatesDir, "components", "layout"),
+        path2.join(srcDir, "components", "layout"),
         { recursive: true }
       );
       await cp(
-        path3.join(templatesDir, "components", "dashboard"),
-        path3.join(srcDir, "components", "dashboard"),
+        path2.join(templatesDir, "components", "dashboard"),
+        path2.join(srcDir, "components", "dashboard"),
         { recursive: true }
       );
-      await mkdir(path3.join(srcDir, "lib"), { recursive: true });
+      await mkdir(path2.join(srcDir, "lib"), { recursive: true });
       await cp(
-        path3.join(templatesDir, "lib", "utils.ts"),
-        path3.join(srcDir, "lib", "utils.ts")
+        path2.join(templatesDir, "lib", "utils.ts"),
+        path2.join(srcDir, "lib", "utils.ts")
       );
-      await mkdir(path3.join(srcDir, "hooks"), { recursive: true });
+      await mkdir(path2.join(srcDir, "hooks"), { recursive: true });
       await cp(
-        path3.join(templatesDir, "hooks"),
-        path3.join(srcDir, "hooks"),
+        path2.join(templatesDir, "hooks"),
+        path2.join(srcDir, "hooks"),
         { recursive: true }
       );
       await cp(
-        path3.join(templatesDir, "app", "layout.tsx"),
-        path3.join(srcDir, "app", "layout.tsx")
+        path2.join(templatesDir, "app", "layout.tsx"),
+        path2.join(srcDir, "app", "layout.tsx")
       );
       await cp(
-        path3.join(templatesDir, "app", "page.tsx"),
-        path3.join(srcDir, "app", "page.tsx")
+        path2.join(templatesDir, "app", "page.tsx"),
+        path2.join(srcDir, "app", "page.tsx")
       );
-      await mkdir(path3.join(srcDir, "app", "dashboard"), { recursive: true });
+      await mkdir(path2.join(srcDir, "app", "dashboard"), { recursive: true });
       await cp(
-        path3.join(templatesDir, "app", "dashboard", "page.tsx"),
-        path3.join(srcDir, "app", "dashboard", "page.tsx")
+        path2.join(templatesDir, "app", "dashboard", "page.tsx"),
+        path2.join(srcDir, "app", "dashboard", "page.tsx")
       );
-      await mkdir(path3.join(srcDir, "app", "auth", "login"), { recursive: true });
+      await mkdir(path2.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")
+        path2.join(templatesDir, "app", "auth", "login", "page.tsx"),
+        path2.join(srcDir, "app", "auth", "login", "page.tsx")
       );
       await mergeGlobalStyles(projectPath, templatesDir);
     },
@@ -468,8 +380,8 @@ async function copyTemplate(projectPath) {
   );
 }
 async function mergeGlobalStyles(projectPath, templatesDir) {
-  const templateCssPath = path3.join(templatesDir, "app", "globals.css");
-  const projectCssPath = path3.join(projectPath, "src", "app", "globals.css");
+  const templateCssPath = path2.join(templatesDir, "app", "globals.css");
+  const projectCssPath = path2.join(projectPath, "src", "app", "globals.css");
   try {
     const templateCss = await readFile(templateCssPath, "utf-8");
     const existingCss = await readFile(projectCssPath, "utf-8");
@@ -546,7 +458,7 @@ async function installDependencies(projectPath) {
 
 // src/steps/create-env.ts
 import { writeFile as writeFile2, readFile as readFile2, appendFile } from "fs/promises";
-import path4 from "path";
+import path3 from "path";
 async function createEnvFile(projectPath, supabaseKeys) {
   await withSpinner(
     "Creando archivo .env.local...",
@@ -557,10 +469,10 @@ NEXT_PUBLIC_SUPABASE_ANON_KEY=${supabaseKeys.anonKey}
 SUPABASE_SERVICE_ROLE_KEY=${supabaseKeys.serviceKey}
 `;
       await writeFile2(
-        path4.join(projectPath, ".env.local"),
+        path3.join(projectPath, ".env.local"),
         envContent
       );
-      const gitignorePath = path4.join(projectPath, ".gitignore");
+      const gitignorePath = path3.join(projectPath, ".gitignore");
       try {
         const gitignore = await readFile2(gitignorePath, "utf-8");
         if (!gitignore.includes(".env.local")) {
@@ -604,6 +516,53 @@ async function setupGit(projectPath, remoteUrl) {
   );
 }
 
+// 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/banner.ts
 import boxen from "boxen";
 import chalk2 from "chalk";
@@ -645,7 +604,7 @@ async function createProject(projectName, options = {}) {
   if (!validation.valid) {
     throw new Error(validation.error);
   }
-  const projectPath = path5.resolve(process.cwd(), projectName);
+  const projectPath = path4.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");
@@ -668,7 +627,7 @@ async function createProject(projectName, options = {}) {
   logger.table(resources);
   logger.newLine();
   if (!options.autoConfirm) {
-    const shouldContinue = await confirm2({
+    const shouldContinue = await confirm({
       message: "\xBFContinuar con la creaci\xF3n?",
       default: true
     });