dex-termux-cli 0.2.3 → 0.3.0-beta.2

package/README.md

@@ -7,89 +7,86 @@
 <h1 align="center">Dex Termux CLI</h1>
 
 <p align="center">
-  CLI visual para Termux con búsqueda guiada, árbol legible, explicación de comandos, contexto de proyecto y flujos de instalación segura para proyectos dentro de Android storage.
+  CLI visual para Termux y Linux con busqueda guiada, tree legible, contexto de proyecto, version visible y flujos seguros para Python, Node y PHP.
 </p>
 
 <p align="center">
-  <img alt="platform" src="https://img.shields.io/badge/platform-Termux-111111?style=flat-square&labelColor=F97316&color=1F2937">
-  <img alt="storage" src="https://img.shields.io/badge/storage-Android-111111?style=flat-square&labelColor=0F766E&color=1F2937">
+  <img alt="platform" src="https://img.shields.io/badge/platform-Termux%20%7C%20Linux-111111?style=flat-square&labelColor=F97316&color=1F2937">
   <img alt="safe-mode" src="https://img.shields.io/badge/safe%20mode-Python%20%7C%20Node%20%7C%20PHP-111111?style=flat-square&labelColor=2563EB&color=1F2937">
-  <img alt="status" src="https://img.shields.io/badge/status-active-111111?style=flat-square&labelColor=7C3AED&color=1F2937">
+  <img alt="channel" src="https://img.shields.io/badge/channel-beta-111111?style=flat-square&labelColor=B45309&color=1F2937">
 </p>
 
 <p align="center">
   <strong>Explorar.</strong> <strong>Entender.</strong> <strong>Instalar.</strong> <strong>Entrar al modo seguro.</strong>
 </p>
 
-> Estado actual: soporte seguro para Python, Node y PHP, con lectura compacta del contexto del proyecto actual.
+> Estado actual: beta `0.3.0-beta.1` con soporte seguro para Python, Node y PHP, contexto de proyecto y modo de plataforma `auto | termux | linux`.
 
-## Visión general
+## Vision general
 
-Dex está pensado para mejorar el trabajo diario en Termux cuando el proyecto vive dentro de almacenamiento Android. En lugar de obligar al usuario a resolver todo manualmente, Dex ofrece una capa más clara para explorar, entender y preparar proyectos sin perder control del entorno real.
+Dex mejora tareas comunes de terminal sin tapar el entorno real. Sirve para explorar carpetas, entender comandos, detectar proyectos y preparar instalaciones con una capa mas clara encima de Termux o Linux.
 
-## En qué destaca
+## Lo que ya incluye
 
-- interfaz más legible para tareas comunes de terminal
-- detección del lenguaje del proyecto actual con versión recortada
-- instalación segura para proyectos en Android storage
-- shell segura por proyecto con el contexto correcto
-- enfoque práctico en lugar de automatización opaca
-
-## Capacidades principales
-
-| Comando | Uso principal |
-| --- | --- |
-| `dex -m` | abre el menú principal |
-| `dex -v` | muestra la versión local y revisa la publicada |
-| `dex -c` | muestra el contexto del proyecto actual |
-| `dex -b` | busca archivos o carpetas |
-| `dex -e` | explica comandos comunes |
-| `dex -t` | muestra árbol guiado |
-| `dex -a` | acceso rápido a Android |
-| `dex -i` | instala dependencias del proyecto actual |
-| `dex -r` | abre el modo seguro del proyecto |
-
-## Qué resuelve
-
-- salida visual más clara que varios comandos crudos de terminal
-- exploración rápida de carpetas y archivos sin recordar tanta sintaxis
-- detección del lenguaje del proyecto actual con una vista compacta útil para prompt
-- instalación segura cuando Android storage rompe el flujo normal
-- shell segura por proyecto para seguir trabajando con el entorno correcto
+- `dex -m`: menu principal
+- `dex -v`: version local y publicada
+- `dex -c`: contexto del proyecto actual
+- `dex --prompt-context`: badge compacto para prompt
+- `dex -b`: busqueda guiada
+- `dex -e`: explicacion de comandos comunes
+- `dex -t`: tree guiado
+- `dex -a`: shell de acceso rapido redisenada para Android storage en Termux o para HOME en Linux
+- `dex -i`: instalacion del proyecto actual incluso desde subcarpetas del proyecto
+- `dex -r`: shell segura del proyecto actual incluso desde subcarpetas del proyecto
 
 ## Contexto del proyecto
 
-Dex puede detectar el tipo de proyecto desde la carpeta actual y resumirlo en una forma compacta como `PY 3.11`, `NODE 20` o `PHP 8.2`. Ese formato está pensado tanto para el comando `dex -c` como para integrarlo al prompt de la terminal.
-
-## Instalación segura por lenguaje
+Dex detecta el lenguaje segun los archivos del directorio actual y tambien desde estructuras simples como `src/main.py` o `app/main.js`. El badge compacto del prompt usa formato limpio como `PYTHON`, `NODE` o `PHP`. La version detectada del runtime se ve en `dex -c`, no dentro del badge.
 
-| Lenguaje | Estrategia de instalación | Modo seguro |
-| --- | --- | --- |
-| Python | `pip`, `requirements.txt`, `pyproject.toml`, `setup.py` o imports inferidos | `venv` seguro |
-| Node | `npm ci` o `npm install` | copia segura del proyecto en `HOME` |
-| PHP | `composer install --no-interaction` | copia segura del proyecto en `HOME` |
-
-## Cómo funciona el modo seguro
+Lenguajes detectables actualmente:
 
-### Python
-Dex prepara un `venv` seguro y abre una shell con el entorno correcto para ejecutar `python`, `pip` o el entrypoint del proyecto.
+- Python
+- Node
+- PHP
+- Rust
+- Go
+- Java
+- Ruby
 
-### Node
-Dex puede trabajar con una copia segura del proyecto fuera de Android storage para que `npm` y `node_modules` no choquen con las limitaciones del almacenamiento compartido.
+## Modo de plataforma
 
-### PHP
-Dex puede instalar dependencias con `composer` en una copia segura del proyecto y abrir una shell lista para seguir trabajando desde ahí.
+Dex puede trabajar en tres modos:
 
-## Estado actual
+- `auto`: detecta si estas en Termux o Linux
+- `termux`: habilita Android storage y restricciones propias de Termux
+- `linux`: desactiva Android y trabaja como entorno Linux puro
 
-- instalación segura activa para Python, Node y PHP
-- shell segura activa para Python, Node y PHP
-- menú y ayuda con una salida más clara
-- lectura del proyecto centrada en Termux y Android storage
+El modo actual se guarda en `~/.config/dex/config.json`.
 
-## Roadmap
+## Instalacion segura por lenguaje
 
-- soporte seguro para Ruby, Go y Rust
-- mejor traducción de errores nativos y de compilación
-- ejecución guiada de entrypoints del proyecto
-- refinamiento final de branding y presentación pública
+| Lenguaje | Estrategia | Modo seguro |
+| --- | --- | --- |
+| Python | `pip`, `requirements.txt`, `pyproject.toml`, `setup.py` o imports inferidos | `venv` seguro |
+| Node | `npm ci` o `npm install` | workspace seguro en `HOME` |
+| PHP | `composer install --no-interaction` | workspace seguro en `HOME` |
+| Ruby | `bundle install` | workspace seguro en `HOME` |
+| Go | `go mod download` | workspace seguro en `HOME` |
+| Rust | `cargo fetch` | workspace seguro en `HOME` |
+| Java | `mvn dependency:go-offline`, `./mvnw dependency:go-offline`, `gradle dependencies` o `./gradlew dependencies` | workspace seguro en `HOME` |
+
+## Estado real de la beta
+
+- `dex -m`, `-a`, `-b`, `-t`, `-v`, `-c` y `--prompt-context` funcionan
+- `dex -a` ahora abre una shell de acceso rapido con prompt propio y atajos. En Termux apunta a Android storage y en Linux apunta a HOME
+- `dex -i` funciona en proyectos validos y ahora usa el root detectado del proyecto aunque entres desde una subcarpeta
+- `dex -r` funciona para proyectos soportados, hereda mejor el root del proyecto y en Termux exige Android storage
+- el modo seguro real ya cubre Python, Node, PHP, Ruby, Go, Rust y Java
+- `dex -e` ya resuelve su data interna sin depender del directorio actual
+
+## Roadmap inmediato
+
+- pulir textos y mensajes de error
+- validar modo Linux de punta a punta
+- seguir puliendo mensajes, UX y validacion prolongada en Linux y Java
+- explorar ejecucion guiada de entrypoints

package/data/commands/explain.json

@@ -70,5 +70,68 @@
       "Puede ser lento en rutas muy grandes.",
       "Dex -b esta pensado precisamente para evitarte recordar esta sintaxis."
     ]
+  },
+  "pwd": {
+    "summary": "Muestra la ruta actual donde estas parado.",
+    "usage": "pwd",
+    "risk": "bajo",
+    "notes": [
+      "Es util para confirmar si Dex te movio al root del proyecto o al workspace seguro.",
+      "En Android storage puede mostrar /storage/emulated/0 aunque entres por /sdcard."
+    ]
+  },
+  "mkdir": {
+    "summary": "Crea carpetas nuevas.",
+    "usage": "mkdir carpeta\nmkdir -p ruta/larga",
+    "risk": "bajo",
+    "notes": [
+      "Usa -p para crear rutas completas sin error si parte del camino ya existe.",
+      "No borra ni sobrescribe contenido existente."
+    ]
+  },
+  "npm": {
+    "summary": "Gestiona dependencias y scripts de proyectos Node.",
+    "usage": "npm install\nnpm ci\nnpm run dev",
+    "risk": "medio",
+    "notes": [
+      "npm ci es mejor cuando ya existe package-lock.json y quieres una instalacion reproducible.",
+      "En Android storage Dex puede rescatar proyectos Node en un workspace seguro dentro de HOME."
+    ]
+  },
+  "node": {
+    "summary": "Ejecuta codigo JavaScript y proyectos Node.",
+    "usage": "node app.js\nnode -v\nnode -e \"console.log(1)\"",
+    "risk": "bajo",
+    "notes": [
+      "Si el proyecto usa dependencias locales, entra primero al root correcto o al workspace seguro.",
+      "Dex usa node tambien para correr su propio CLI."
+    ]
+  },
+  "python": {
+    "summary": "Ejecuta scripts Python e inspecciona el runtime actual.",
+    "usage": "python bot.py\npython -V\npython -m pip list",
+    "risk": "bajo",
+    "notes": [
+      "Dentro de safe-shell puede apuntar a un venv preparado por Dex.",
+      "python -m pip suele ser mas fiable que usar pip suelto."
+    ]
+  },
+  "pip": {
+    "summary": "Instala y gestiona paquetes Python.",
+    "usage": "pip install paquete\npip install -r requirements.txt",
+    "risk": "medio",
+    "notes": [
+      "En proyectos sensibles conviene usar venv o el modo seguro de Dex.",
+      "Si estas en Android storage, Dex puede rescatar la instalacion automaticamente en ciertos casos."
+    ]
+  },
+  "composer": {
+    "summary": "Instala dependencias y maneja proyectos PHP.",
+    "usage": "composer install\ncomposer update\ncomposer dump-autoload",
+    "risk": "medio",
+    "notes": [
+      "En Dex, composer puede ejecutarse dentro de un workspace seguro para evitar problemas de Android storage.",
+      "composer update cambia versiones; composer install intenta respetar composer.lock."
+    ]
   }
 }

package/package.json

@@ -1,15 +1,20 @@
 {
   "name": "dex-termux-cli",
-  "version": "0.2.3",
+  "version": "0.3.0-beta.2",
   "type": "module",
-  "description": "Termux CLI for Android with guided search, readable tree views, command help, and safe project install flows for Python, Node, and PHP.",
+  "description": "Visual CLI for Termux and Linux with guided search, readable tree views, project context, version checks, Android mode, and safe flows for Python, Node, PHP, Ruby, Go, Rust, and Java.",
   "keywords": [
     "termux",
+    "linux",
     "android",
     "cli",
     "python",
     "node",
     "php",
+    "ruby",
+    "go",
+    "rust",
+    "java",
     "safe-shell"
   ],
   "license": "MIT",
@@ -18,7 +23,8 @@
   },
   "scripts": {
     "start": "node ./bin/dex",
-    "help": "node ./bin/dex --help"
+    "help": "node ./bin/dex --help",
+    "test": "node --test ./tests/**/*.test.js"
   },
   "author": "farllirs",
   "files": [

package/src/app/main.js

@@ -15,7 +15,7 @@ import { detectProjectContext, formatProjectContext } from '../utils/project-con
 export async function main(argv = process.argv.slice(2)) {
   const parsed = parseArgs(argv);
   const config = await loadUserConfig();
-  const isPromptOnly = parsed.command === 'prompt-context';
+  const isPromptOnly = parsed.command === 'prompt-context' || parsed.command === 'prompt-project-root' || parsed.command === 'prompt-project-path';
   const isContextOnly = parsed.command === 'context';
   const isVersionOnly = parsed.command === 'version';
 
@@ -46,6 +46,16 @@ export async function main(argv = process.argv.slice(2)) {
     return;
   }
 
+  if (parsed.command === 'prompt-project-root') {
+    await runContextCommand({ projectRoot: true });
+    return;
+  }
+
+  if (parsed.command === 'prompt-project-path') {
+    await runContextCommand({ projectPath: true });
+    return;
+  }
+
   if (parsed.command === 'search') {
     await runSearchCommand(parsed);
     return;

package/src/commands/android-shell.js

@@ -1,55 +1,248 @@
 import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { getUserConfigPath, loadUserConfig } from '../core/config.js';
 import { resolveInteractiveShell } from '../utils/shell.js';
+import {
+  getQuickAccessAliases,
+  getQuickAccessLabel,
+  getQuickAccessModeDescription,
+  getQuickAccessRoot,
+  getQuickAccessShortcutSummary,
+  getQuickAccessTitle,
+  resolvePlatformMode,
+} from '../utils/platform.js';
 
-const ANDROID_ROOT = '/sdcard';
+const ANDROID_BASH_CANDIDATES = [
+  '/data/data/com.termux/files/usr/bin/bash',
+  '/bin/bash',
+];
 
 export async function runAndroidShellCommand() {
   const config = await loadUserConfig();
 
   if (!config.features.androidShortcut) {
     throw new Error(
-      `La opcion Android esta desactivada. Activa features.androidShortcut en ${getUserConfigPath()}`,
+      `El acceso rapido esta desactivado. Activa features.androidShortcut en ${getUserConfigPath()}`,
     );
   }
 
+  const platformMode = resolvePlatformMode(config);
+  const quickAccessRoot = getQuickAccessRoot(platformMode);
+
   try {
-    await fs.access(ANDROID_ROOT);
+    await fs.access(quickAccessRoot);
   } catch {
-    throw new Error(`No se puede acceder a la ruta Android: ${ANDROID_ROOT}`);
+    throw new Error(`No se puede acceder a la ruta base de acceso rapido: ${quickAccessRoot}`);
   }
 
-  const interactiveShell = await resolveInteractiveShell();
+  const interactiveShell = await resolveAndroidInteractiveShell(platformMode);
+  const shellSession = await createQuickAccessShellSession(platformMode, interactiveShell);
 
-  console.log(`Abriendo shell en ${ANDROID_ROOT}`);
+  console.log(getQuickAccessTitle(platformMode));
+  console.log('');
+  console.log(`Raiz    : ${quickAccessRoot}`);
   console.log(`Shell   : ${interactiveShell.shellName} interactiva`);
-  console.log('Escribe exit para volver.');
+  console.log(`Modo    : ${getQuickAccessModeDescription(platformMode)}`);
+  console.log(`Atajos  : ${getQuickAccessShortcutSummary(platformMode)}`);
+  console.log('Salida  : escribe exit para volver');
   console.log('');
 
-  await new Promise((resolve, reject) => {
-    const child = spawn(interactiveShell.shellPath, interactiveShell.shellArgs, {
-      cwd: ANDROID_ROOT,
-      stdio: 'inherit',
-      env: {
-        ...process.env,
-        DEX_CONTEXT: 'android-shell',
-      },
-    });
+  try {
+    await new Promise((resolve, reject) => {
+      const child = spawn(shellSession.shellPath, shellSession.shellArgs, {
+        cwd: quickAccessRoot,
+        stdio: 'inherit',
+        env: {
+          ...process.env,
+          ...shellSession.env,
+          DEX_CONTEXT: platformMode === 'termux' ? 'android-shell' : 'linux-shell',
+          DEX_ANDROID_ROOT: quickAccessRoot,
+          DEX_ANDROID_LABEL: getQuickAccessLabel(platformMode),
+          DEX_ANDROID_SHELL: interactiveShell.shellName,
+        },
+      });
 
-    child.on('error', reject);
-    child.on('exit', (code, signal) => {
-      if (signal) {
-        reject(new Error(`La shell Android termino por senal: ${signal}`));
-        return;
-      }
+      child.on('error', reject);
+      child.on('exit', (code, signal) => {
+        if (signal) {
+          reject(new Error(`La shell de acceso rapido termino por senal: ${signal}`));
+          return;
+        }
 
-      if (code && code !== 0) {
-        reject(new Error(`La shell Android termino con codigo ${code}`));
-        return;
-      }
+        if (code && code !== 0) {
+          reject(new Error(`La shell de acceso rapido termino con codigo ${code}`));
+          return;
+        }
 
-      resolve();
+        resolve();
+      });
     });
+  } finally {
+    await shellSession.cleanup();
+  }
+}
+
+async function resolveAndroidInteractiveShell(platformMode) {
+  const interactiveShell = await resolveInteractiveShell(platformMode);
+
+  if (interactiveShell.shellName !== 'sh') {
+    return interactiveShell;
+  }
+
+  for (const shellPath of ANDROID_BASH_CANDIDATES) {
+    try {
+      await fs.access(shellPath);
+      return {
+        shellPath,
+        shellArgs: ['-i'],
+        shellName: 'bash',
+      };
+    } catch {
+      // sigue con el siguiente candidato
+    }
+  }
+
+  return interactiveShell;
+}
+
+async function createQuickAccessShellSession(platformMode, interactiveShell) {
+  const tmpBase = await fs.mkdtemp(path.join(os.tmpdir(), 'dex-shell-'));
+  const aliases = getQuickAccessAliases(platformMode);
+  const root = getQuickAccessRoot(platformMode);
+  const label = getQuickAccessLabel(platformMode);
+  const rcContent = buildShellRc({
+    aliases,
+    root,
+    label,
+    shellName: interactiveShell.shellName,
+    platformMode,
   });
+
+  if (interactiveShell.shellName === 'bash') {
+    const rcPath = path.join(tmpBase, 'dex-bashrc');
+    await fs.writeFile(rcPath, rcContent, 'utf8');
+    return {
+      shellPath: interactiveShell.shellPath,
+      shellArgs: ['--rcfile', rcPath, '-i'],
+      env: {},
+      cleanup: () => fs.rm(tmpBase, { recursive: true, force: true }),
+    };
+  }
+
+  if (interactiveShell.shellName === 'zsh') {
+    const zdotdir = path.join(tmpBase, 'zsh');
+    await fs.mkdir(zdotdir, { recursive: true });
+    await fs.writeFile(path.join(zdotdir, '.zshrc'), rcContent, 'utf8');
+    return {
+      shellPath: interactiveShell.shellPath,
+      shellArgs: ['-i'],
+      env: { ZDOTDIR: zdotdir },
+      cleanup: () => fs.rm(tmpBase, { recursive: true, force: true }),
+    };
+  }
+
+  const rcPath = path.join(tmpBase, 'dex-shrc');
+  await fs.writeFile(rcPath, rcContent, 'utf8');
+  return {
+    shellPath: interactiveShell.shellPath,
+    shellArgs: ['-i'],
+    env: { ENV: rcPath },
+    cleanup: () => fs.rm(tmpBase, { recursive: true, force: true }),
+  };
+}
+
+function buildShellRc({ aliases, root, label, shellName, platformMode }) {
+  if (platformMode === 'termux') {
+    return buildTermuxShellRc(shellName);
+  }
+
+  return buildLinuxShellRc({ aliases, root, label, shellName });
+}
+
+function buildTermuxShellRc(shellName) {
+  const lines = [
+    '# dex quick access shell',
+    'export PATH="$HOME/bin:$PATH"',
+  ];
+
+  if (shellName === 'zsh') {
+    lines.push('[[ -f "$HOME/.zshrc" ]] && source "$HOME/.zshrc"');
+    lines.push('printf "Dex: acceso rapido cargado en %s\\n" "$PWD"');
+    return lines.join('\n') + '\n';
+  }
+
+  if (shellName === 'bash') {
+    lines.push('[[ -f "$HOME/.bashrc" ]] && source "$HOME/.bashrc"');
+    lines.push('printf "Dex: acceso rapido cargado en %s\\n" "$PWD"');
+    return lines.join('\n') + '\n';
+  }
+
+  lines.push('printf "Dex: acceso rapido cargado en %s\\n" "$PWD"');
+  return lines.join('\n') + '\n';
+}
+
+function buildLinuxShellRc({ aliases, root, label, shellName }) {
+  const aliasLines = Object.entries(aliases).map(([name, target]) => `alias ${name}='cd "${target}"'`);
+  const commonLines = [
+    '# dex quick access shell',
+    'export PATH="$HOME/bin:$PATH"',
+    `export DEX_QUICK_ROOT="${root}"`,
+    `export DEX_QUICK_LABEL="${label}"`,
+    ...aliasLines,
+  ];
+
+  if (shellName === 'zsh') {
+    return [
+      ...commonLines,
+      '[[ -f "$HOME/.zshrc" ]] && source "$HOME/.zshrc"',
+      '_dex_linux_project_badge_zsh() {',
+      '  local dex_bin context',
+      '  dex_bin="$(command -v dex 2>/dev/null)"',
+      '  [[ -z "$dex_bin" ]] && return',
+      '  context="$($dex_bin --prompt-context 2>/dev/null)"',
+      '  [[ -z "$context" ]] && return',
+      '  print -n "%F{81}[$context]%f"',
+      '}',
+      '_dex_linux_prompt_zsh() {',
+      '  local badge',
+      '  badge="$(_dex_linux_project_badge_zsh)"',
+      "  PROMPT=$'%F{45}Dex@linux%f %F{117}%~%f\\n%F{45}>%f '",
+      '  RPROMPT="$badge"',
+      '}',
+      'autoload -Uz add-zsh-hook 2>/dev/null || true',
+      'add-zsh-hook precmd _dex_linux_prompt_zsh 2>/dev/null || true',
+      '_dex_linux_prompt_zsh',
+      'printf "Dex: acceso rapido cargado en %s\\n" "$PWD"',
+    ].join('\n') + '\n';
+  }
+
+  if (shellName === 'bash') {
+    return [
+      ...commonLines,
+      '_dex_linux_project_badge_bash() {',
+      '  local dex_bin context',
+      '  dex_bin="$(command -v dex 2>/dev/null)"',
+      '  [[ -z "$dex_bin" ]] && return',
+      '  context="$($dex_bin --prompt-context 2>/dev/null)"',
+      '  [[ -z "$context" ]] && return',
+      '  printf "\\[\\e[38;5;81m\\][%s]\\[\\e[0m\\]" "$context"',
+      '}',
+      '_dex_linux_prompt_bash() {',
+      '  local badge',
+      '  badge="$(_dex_linux_project_badge_bash)"',
+      '  PS1="\\[\\e[38;5;45m\\]Dex@linux\\[\\e[0m\\] \\[\\e[38;5;117m\\]\\w\\[\\e[0m\\] ${badge}\\n\\[\\e[38;5;45m\\]>\\[\\e[0m\\] "',
+      '}',
+      'PROMPT_COMMAND=_dex_linux_prompt_bash',
+      '_dex_linux_prompt_bash',
+      'printf "Dex: acceso rapido cargado en %s\\n" "$PWD"',
+    ].join('\n') + '\n';
+  }
+
+  return [
+    ...commonLines,
+    `export PS1='[dex ${label}] \\w \\$ '`,
+    'printf "Dex: acceso rapido cargado en %s\\n" "$PWD"',
+  ].join('\n') + '\n';
 }

package/src/commands/context.js

@@ -2,6 +2,8 @@ import {
   detectProjectContext,
   formatProjectContext,
   formatPromptContext,
+  formatPromptProjectRoot,
+  formatPromptProjectPath,
   formatProjectContextDetails,
 } from '../utils/project-context.js';
 
@@ -9,6 +11,26 @@ export async function runContextCommand(options = {}) {
   const context = await detectProjectContext();
 
   if (!context) {
+    if (!options.prompt && !options.projectRoot && !options.projectPath) {
+      console.log('No detecte un proyecto compatible en esta carpeta.');
+      console.log('Prueba entrando a un proyecto Python, Node, PHP, Rust, Go, Java o Ruby.');
+    }
+    return;
+  }
+
+  if (options.projectRoot) {
+    const rootName = formatPromptProjectRoot(context);
+    if (rootName) {
+      process.stdout.write(rootName);
+    }
+    return;
+  }
+
+  if (options.projectPath) {
+    const projectPath = formatPromptProjectPath(context);
+    if (projectPath) {
+      process.stdout.write(projectPath);
+    }
     return;
   }
 

package/src/commands/explain.js

@@ -1,13 +1,15 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { printExplainEntry, printSection } from '../ui/output.js';
 import { chooseExplainTopic } from '../ui/prompt.js';
 
-const EXPLAIN_DATA_PATH = path.resolve(process.cwd(), 'data/commands/explain.json');
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const EXPLAIN_DATA_PATH = path.resolve(MODULE_DIR, '..', '..', 'data', 'commands', 'explain.json');
 
 export async function runExplainCommand({ topic }) {
   const entries = await loadExplainEntries();
-  const selectedTopic = topic ? topic.toLowerCase() : await chooseExplainTopic(entries);
+  const selectedTopic = topic ? normalizeTopic(topic) : await chooseExplainTopic(entries);
   const entry = entries[selectedTopic];
 
   if (!entry) {
@@ -23,3 +25,10 @@ async function loadExplainEntries() {
   const raw = await fs.readFile(EXPLAIN_DATA_PATH, 'utf8');
   return JSON.parse(raw);
 }
+
+function normalizeTopic(topic) {
+  return String(topic)
+    .trim()
+    .split(/\s+/)[0]
+    .toLowerCase();
+}