fractalia-faro 0.1.0 → 0.4.0

package/bin/crear.mjs

@@ -68,6 +68,13 @@ const NATURALEZAS = {
 const CONFIG_PATH = path.join(os.homedir(), '.fractalia-cli.json');
 const API = 'https://api.github.com';
 
+// LOGIN por NAVEGADOR (device flow) para usuarios no técnicos: sin pegar tokens.
+// El client_id es PÚBLICO (no es secreto) -> se embebe aquí. Lo crea un admin de la org UNA vez:
+// GitHub -> org Settings -> Developer settings -> OAuth Apps -> New OAuth App -> ✅ Enable Device Flow.
+// Mientras esté vacío, el wizard usa la vía de reserva (pegar un PAT).
+const DEFAULT_CLIENT_ID = 'Ov23liKk3T9bWKak2wmH';   // OAuth App "Fractalia FARO CLI" de CAS-IA (Client ID público)
+const DEFAULT_ORG = 'CAS-IA';   // organización por defecto (evita teclearla)
+
 // ---------- CLI args ----------
 const args = process.argv.slice(2);
 const DRY = args.includes('--dry-run');
@@ -178,10 +185,25 @@ async function elige(titulo, opciones, preseleccion) {
 
 // Comprobación de prerrequisitos de la máquina (una vez, antes de nada).
 function tieneCmd(bins) { for (const b of bins) { try { execFileSync(b, ['--version'], { stdio: 'ignore', timeout: 8000 }); return true; } catch {} } return false; }
+// Localiza el comando 'code' de VS Code: en PATH o en las rutas de instalación típicas de Windows.
+// (Es común que 'code' no esté en PATH aunque VS Code esté instalado — hay que "Install 'code' command in PATH".)
+function codeBin() {
+  for (const b of ['code', 'code.cmd']) { try { execFileSync(b, ['--version'], { stdio: 'ignore', timeout: 8000 }); return b; } catch {} }
+  const cand = [
+    path.join(os.homedir(), 'AppData', 'Local', 'Programs', 'Microsoft VS Code', 'bin', 'code.cmd'),
+    'C:/Program Files/Microsoft VS Code/bin/code.cmd',
+    'C:/Program Files/Microsoft VS Code Insiders/bin/code-insiders.cmd',
+  ];
+  for (const c of cand) { if (fs.existsSync(c)) return c; }
+  return null;
+}
+const enVSCode = process.env.TERM_PROGRAM === 'vscode';
 function checkPrerrequisitos() {
   const falta = [];
   if (!tieneCmd(['git'])) falta.push('Git (winget install Git.Git)');
-  if (!tieneCmd(['code', 'code.cmd'])) warn('VS Code (comando "code") no detectado — al final tendrás que abrir la carpeta a mano.');
+  if (!codeBin()) warn(enVSCode
+    ? 'El comando "code" no está en el PATH — al final te diré la carpeta para abrirla tú (o instálalo: Ctrl+Shift+P → "Install \'code\' command in PATH").'
+    : 'VS Code (comando "code") no detectado — al final tendrás que abrir la carpeta a mano.');
   if (falta.length) { fail(`Falta instalar: ${falta.join(' · ')}. Instálalo y vuelve a ejecutar (o usa kit/instalar-fractalia.ps1).`); rl.close(); process.exit(1); }
 }
 
@@ -215,6 +237,16 @@ async function gh(token, ruta, init = {}) {
   return { status: res.status, ok: res.ok, body };
 }
 
+// Abre una URL en el navegador del sistema (sin dependencias, multiplataforma).
+function abrirNavegador(url) {
+  try {
+    if (process.platform === 'win32') execFileSync('cmd', ['/c', 'start', '', url], { stdio: 'ignore' });
+    else if (process.platform === 'darwin') execFileSync('open', [url], { stdio: 'ignore' });
+    else execFileSync('xdg-open', [url], { stdio: 'ignore' });
+    return true;
+  } catch { return false; }
+}
+
 // Login SIN contraseñas: GitHub Device Flow (requiere una OAuth App de la org; solo client_id, sin secreto).
 async function deviceFlow(clientId) {
   const form = (o) => Object.entries(o).map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join('&');
@@ -224,8 +256,15 @@ async function deviceFlow(clientId) {
   };
   const d = await post('https://github.com/login/device/code', { client_id: clientId, scope: 'repo read:org' });
   if (!d.device_code) throw new Error(`device flow: ${JSON.stringify(d)}`);
-  say(`\n  1) Abre en el navegador:  ${d.verification_uri}`);
-  say(`  2) Inicia sesión con tu cuenta corporativa y teclea el código:  ${d.user_code}\n`);
+  const abierto = abrirNavegador(d.verification_uri);
+  say('');
+  caja([
+    `${C.b}Inicia sesión en GitHub${C.x} ${C.d}(una sola vez en esta máquina)${C.x}`,
+    '',
+    `${abierto ? 'Te he abierto el navegador en:' : 'Abre en el navegador:'}  ${C.c}${d.verification_uri}${C.x}`,
+    `Teclea este código:  ${C.b}${C.g}${d.user_code}${C.x}`,
+  ], { titulo: 'Login', color: C.c });
+  say(`${C.d}  Esperando a que autorices en el navegador…${C.x}`);
   const intervalo = (d.interval || 5) * 1000;
   for (;;) {
     await new Promise((r) => setTimeout(r, intervalo));
@@ -251,9 +290,9 @@ async function obtenerToken(cfg) {
     const me = await gh(tok, '/user');
     if (me.ok) { ok(`Sesión GitHub válida vía ${via}: @${me.body.login}`); return { token: tok, login: me.body.login }; }
   }
-  const clientId = cfg.client_id || process.env.FRACTALIA_CLIENT_ID;
+  const clientId = cfg.client_id || process.env.FRACTALIA_CLIENT_ID || DEFAULT_CLIENT_ID;
   if (clientId) {
-    say('\nNecesitas iniciar sesión en GitHub (una sola vez en esta máquina).');
+    // Login por NAVEGADOR (lo normal para todos, sin pegar tokens).
     const tok = await deviceFlow(clientId);
     const me = await gh(tok, '/user');
     if (!me.ok) throw new Error('el token del device flow no valida');
@@ -261,8 +300,10 @@ async function obtenerToken(cfg) {
     ok(`Sesión iniciada: @${me.body.login} (guardada para próximas veces)`);
     return { token: tok, login: me.body.login };
   }
-  say('\nNo hay sesión de GitHub. Crea un token personal (PAT clásico, scopes: repo + read:org)');
-  say('en https://github.com/settings/tokens y pégalo aquí (queda guardado en tu máquina).');
+  // Vía de RESERVA (solo si aún no hay OAuth App configurada): pegar un token personal.
+  say('');
+  warn('Login por navegador no disponible todavía (falta configurar la OAuth App de la organización).');
+  say(`${C.d}  Mientras tanto: crea un token en https://github.com/settings/tokens (classic, scopes: repo + read:org) y pégalo (se guarda en tu máquina).${C.x}`);
   const tok = await pregunta('Token de GitHub (ghp_...)');
   const me = await gh(tok, '/user');
   if (!me.ok) throw new Error('el token pegado no es válido');
@@ -289,7 +330,12 @@ const run = (cmd, argv, opts = {}) => execFileSync(cmd, argv, { stdio: 'inherit'
 // Compartida por el flujo normal y por el RESUME (repo ya existente).
 async function finalizarLocal(auth, org, repoName, baseDir, destino, nat, tipo, naturaleza) {
   fs.mkdirSync(baseDir, { recursive: true });
-  if (fs.existsSync(destino)) { warn(`La carpeta ${destino} ya existe: no la sobrescribo. Abre ahí a mano si es el clon.`); }
+  // Se puede clonar en una carpeta que YA existe si está VACÍA (caso "esta carpeta como raíz"); si tiene
+  // contenido, no se pisa.
+  const existe = fs.existsSync(destino);
+  let vacio = !existe;
+  if (existe) { try { vacio = fs.readdirSync(destino).filter((n) => n !== '.git').length === 0; } catch { vacio = false; } }
+  if (existe && !vacio) { warn(`La carpeta ${destino} ya existe y NO está vacía: no la sobrescribo. Abre ahí a mano si es el clon.`); }
   else {
     run('git', ['clone', `https://x-access-token:${auth.token}@github.com/${org}/${repoName}.git`, destino]);
     run('git', ['-C', destino, 'remote', 'set-url', 'origin', `https://github.com/${org}/${repoName}.git`]);
@@ -317,10 +363,9 @@ async function finalizarLocal(auth, org, repoName, baseDir, destino, nat, tipo,
   } else if (cuToken) ok('ClickUp key personal ya configurada en esta máquina.');
   // Abrir VS Code (salvo --no-open).
   if (NO_OPEN) { ok(`Listo. Abre la carpeta: ${destino}`); return; }
-  let abierto = false;
-  for (const bin of ['code', 'code.cmd']) { try { execFileSync(bin, [destino], { stdio: 'ignore' }); abierto = true; break; } catch {} }
-  if (abierto) ok('Abriendo VS Code…');
-  else warn(`No pude abrir VS Code automáticamente: abre la carpeta ${destino} a mano.`);
+  const cb = codeBin();
+  if (cb) { try { execFileSync(cb, [destino], { stdio: 'ignore' }); ok('Abriendo VS Code…'); } catch { warn(`Abre la carpeta a mano: ${destino}`); } }
+  else warn(`VS Code no está en el PATH. Abre esta carpeta a mano: ${destino}`);
 }
 
 // ---------- flujo principal ----------
@@ -389,10 +434,26 @@ async function main() {
     if (nombreFlag || await confirma('¿Correcto?')) break;
   }
 
-  // 5. Carpeta local de trabajo (--dir lo pasa directo).
-  const defDir = cfg.workdir || path.join(os.homedir(), 'PROYECTOS');
-  const baseDir = argVal('dir') || await pregunta('Carpeta donde clonarlo', defDir);
-  const destino = path.join(baseDir, repoName);
+  // 5. Dónde clonar. Por defecto la carpeta ACTUAL (donde ejecutas el wizard); eliges raíz o subcarpeta,
+  //    y se detecta si la carpeta ya es un repo o tiene contenido para no pisar nada.
+  let destino;
+  const dirFlag = argVal('dir');
+  const cwd = process.cwd();
+  if (dirFlag) destino = path.join(dirFlag, repoName);
+  else if (YES) destino = path.join(cwd, repoName);
+  else {
+    const esRepo = fs.existsSync(path.join(cwd, '.git'));
+    let vacia = false; try { vacia = fs.readdirSync(cwd).filter((n) => n !== '.git' && !n.startsWith('.')).length === 0; } catch {}
+    const ops = { sub: { etiqueta: `Aquí, en una subcarpeta  →  ${path.join(cwd, repoName)}`, explica: 'Recomendado: crea la carpeta del proyecto DENTRO de la actual.' } };
+    if (!esRepo && vacia) ops.raiz = { etiqueta: `Esta misma carpeta como raíz  →  ${cwd}`, explica: 'La carpeta actual está vacía: el proyecto será ESTA carpeta, sin subcarpeta.' };
+    ops.otra = { etiqueta: 'Otra carpeta…', explica: 'Indicas tú la ruta contenedora.' };
+    if (esRepo) warn('La carpeta actual ya es un repositorio git → se usará una subcarpeta (no se puede anidar).');
+    const donde = await elige(`¿Dónde creamos el proyecto?  ${C.d}(estás en ${cwd})${C.x}`, ops);
+    if (donde === 'raiz') destino = cwd;
+    else if (donde === 'otra') { const base = await pregunta('Ruta de la carpeta contenedora', cfg.workdir || cwd); destino = path.join(base, repoName); }
+    else destino = path.join(cwd, repoName);
+  }
+  const baseDir = path.dirname(destino);
   cfg.workdir = baseDir; saveConfig(cfg);
 
   // Resumen previo en caja.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fractalia-faro",
-  "version": "0.1.0",
+  "version": "0.4.0",
   "description": "Wizard FARO: crea un repo de trabajo (servicio/funcionalidad de plataforma, proyecto o iniciativa) desde el template oficial, con nomenclatura, ramas main+develop y clon local listo.",
   "bin": {
     "faro": "bin/crear.mjs"