dex-termux-cli 0.1.1 → 0.2.1

package/README.md

@@ -7,7 +7,7 @@
 <h1 align="center">Dex Termux CLI</h1>
 
 <p align="center">
-  CLI visual para Termux con búsqueda guiada, árbol legible, explicación de comandos y flujos de instalación segura para proyectos dentro de Android storage.
+  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.
 </p>
 
 <p align="center">
@@ -21,7 +21,7 @@
   <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.
+> Estado actual: soporte seguro para Python, Node y PHP, con lectura compacta del contexto del proyecto actual.
 
 ## Visión general
 
@@ -30,7 +30,7 @@ Dex está pensado para mejorar el trabajo diario en Termux cuando el proyecto vi
 ## En qué destaca
 
 - interfaz más legible para tareas comunes de terminal
-- detección del lenguaje del proyecto actual
+- 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
@@ -40,6 +40,8 @@ Dex está pensado para mejorar el trabajo diario en Termux cuando el proyecto vi
 | 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 |
@@ -51,10 +53,14 @@ Dex está pensado para mejorar el trabajo diario en Termux cuando el proyecto vi
 
 - 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
+- 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
 
+## 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
 
 | Lenguaje | Estrategia de instalación | Modo seguro |
@@ -78,7 +84,7 @@ Dex puede instalar dependencias con `composer` en una copia segura del proyecto
 
 - instalación segura activa para Python, Node y PHP
 - shell segura activa para Python, Node y PHP
-- branding base ya integrado al repositorio
+- menú y ayuda con una salida más clara
 - lectura del proyecto centrada en Termux y Android storage
 
 ## Roadmap

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dex-termux-cli",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "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.",
   "keywords": [

package/src/app/main.js

@@ -1,20 +1,25 @@
 import { parseArgs } from '../core/args.js';
 import { loadUserConfig } from '../core/config.js';
 import { runAndroidShellCommand } from '../commands/android-shell.js';
+import { runContextCommand } from '../commands/context.js';
 import { runExplainCommand } from '../commands/explain.js';
 import { runInstallCommand } from '../commands/install.js';
 import { runMenuCommand } from '../commands/menu.js';
 import { runSafeShellCommand } from '../commands/safe-shell.js';
 import { runSearchCommand } from '../commands/search.js';
 import { runTreeCommand } from '../commands/tree.js';
+import { runVersionCommand } from '../commands/version.js';
 import { printHelp, printProjectContextLine } from '../ui/output.js';
 import { detectProjectContext, formatProjectContext } from '../utils/project-context.js';
 
 export async function main(argv = process.argv.slice(2)) {
   const parsed = parseArgs(argv);
   const config = await loadUserConfig();
+  const isPromptOnly = parsed.command === 'prompt-context';
+  const isContextOnly = parsed.command === 'context';
+  const isVersionOnly = parsed.command === 'version';
 
-  if (config.features.projectBadge) {
+  if (config.features.projectBadge && !isPromptOnly && !isContextOnly && !isVersionOnly) {
     const context = await detectProjectContext();
     if (context) {
       printProjectContextLine(formatProjectContext(context));
@@ -26,6 +31,21 @@ export async function main(argv = process.argv.slice(2)) {
     return;
   }
 
+  if (parsed.command === 'version') {
+    await runVersionCommand();
+    return;
+  }
+
+  if (parsed.command === 'context') {
+    await runContextCommand();
+    return;
+  }
+
+  if (parsed.command === 'prompt-context') {
+    await runContextCommand({ prompt: true });
+    return;
+  }
+
   if (parsed.command === 'search') {
     await runSearchCommand(parsed);
     return;

package/src/commands/android-shell.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs/promises';
 import { spawn } from 'node:child_process';
 import { getUserConfigPath, loadUserConfig } from '../core/config.js';
+import { resolveInteractiveShell } from '../utils/shell.js';
 
 const ANDROID_ROOT = '/sdcard';
 
@@ -19,14 +20,15 @@ export async function runAndroidShellCommand() {
     throw new Error(`No se puede acceder a la ruta Android: ${ANDROID_ROOT}`);
   }
 
-  const shell = process.env.SHELL || '/data/data/com.termux/files/usr/bin/sh';
+  const interactiveShell = await resolveInteractiveShell();
 
   console.log(`Abriendo shell en ${ANDROID_ROOT}`);
+  console.log(`Shell   : ${interactiveShell.shellName} interactiva`);
   console.log('Escribe exit para volver.');
   console.log('');
 
   await new Promise((resolve, reject) => {
-    const child = spawn(shell, {
+    const child = spawn(interactiveShell.shellPath, interactiveShell.shellArgs, {
       cwd: ANDROID_ROOT,
       stdio: 'inherit',
       env: {

package/src/commands/context.js

@@ -0,0 +1,26 @@
+import {
+  detectProjectContext,
+  formatProjectContext,
+  formatPromptContext,
+  formatProjectContextDetails,
+} from '../utils/project-context.js';
+
+export async function runContextCommand(options = {}) {
+  const context = await detectProjectContext();
+
+  if (!context) {
+    return;
+  }
+
+  if (options.prompt) {
+    const line = formatPromptContext(context);
+    if (line) {
+      process.stdout.write(line);
+    }
+    return;
+  }
+
+  console.log(formatProjectContext(context));
+  console.log('');
+  console.log(formatProjectContextDetails(context));
+}

package/src/commands/menu.js

@@ -1,11 +1,14 @@
-import { loadUserConfig, setFeatureEnabled } from '../core/config.js';
+import { loadUserConfig, setFeatureEnabled, setPromptContextPosition } from '../core/config.js';
+import { runContextCommand } from './context.js';
 import { runExplainCommand } from './explain.js';
 import { runSafeShellCommand } from './safe-shell.js';
 import { runSearchCommand } from './search.js';
 import { runTreeCommand } from './tree.js';
+import { runVersionCommand } from './version.js';
 import {
   chooseFeatureToggle,
   chooseMenuAction,
+  choosePromptContextPosition,
   chooseSearchPatternFromMenu,
   chooseSettingsAction,
   chooseTreeTargetFromMenu,
@@ -21,6 +24,16 @@ export async function runMenuCommand() {
       return;
     }
 
+    if (action === 'version') {
+      await runVersionCommand();
+      return;
+    }
+
+    if (action === 'context') {
+      await runContextCommand();
+      return;
+    }
+
     if (action === 'search') {
       const pattern = await chooseSearchPatternFromMenu();
       await runSearchCommand({ pattern, scope: '' });
@@ -100,6 +113,19 @@ async function runSettingsMenu() {
       continue;
     }
 
+    if (action === 'prompt-context-position') {
+      const position = await choosePromptContextPosition(config.ui?.promptContextPosition || 'right');
+
+      if (position === 'back') {
+        continue;
+      }
+
+      await setPromptContextPosition(position);
+      console.log('Posicion del contexto del prompt: ' + formatPromptContextPosition(position) + '.');
+      console.log('');
+      continue;
+    }
+
     if (action === 'toggle-smart-project-install') {
       const toggle = await chooseFeatureToggle(
         config.features.smartProjectInstall,
@@ -118,3 +144,15 @@ async function runSettingsMenu() {
     }
   }
 }
+
+function formatPromptContextPosition(position) {
+  if (position === 'inline') {
+    return 'inline junto a la ruta';
+  }
+
+  if (position === 'off') {
+    return 'oculto';
+  }
+
+  return 'a la derecha';
+}

package/src/commands/safe-shell.js

@@ -4,6 +4,7 @@ import { createHash } from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { loadUserConfig } from '../core/config.js';
 import { detectProjectContext } from '../utils/project-context.js';
+import { resolveInteractiveShell } from '../utils/shell.js';
 
 export async function runSafeShellCommand() {
   const config = await loadUserConfig();
@@ -25,7 +26,7 @@ export async function runSafeShellCommand() {
 
   const projectKey = getProjectKey(projectRoot);
   const projectState = config.projects && config.projects[projectKey] ? config.projects[projectKey] : null;
-  const shell = process.env.SHELL || '/data/data/com.termux/files/usr/bin/sh';
+  const interactiveShell = await resolveInteractiveShell();
   const reason = projectState && projectState.preferSafeInstall
     ? 'Este proyecto ya quedo marcado para modo seguro.'
     : 'Entrando al entorno seguro manual de Dex.';
@@ -47,13 +48,14 @@ export async function runSafeShellCommand() {
     console.log('Proyecto : ' + projectRoot);
     console.log('Entorno  : ' + venvDir);
     console.log('Python   : ' + rescuePython);
+    console.log('Shell    : ' + interactiveShell.shellName + ' interactiva');
     console.log('Nota     : ' + reason);
     console.log('Usa python, pip o python bot.py desde aqui.');
     console.log('Si sales de esta shell, el modo seguro deja de estar activo.');
     console.log('Escribe exit para volver a tu shell normal.');
     console.log('');
 
-    await openSafeShell(shell, projectRoot, {
+    await openSafeShell(interactiveShell, projectRoot, {
       PATH: nextPath,
       VIRTUAL_ENV: venvDir,
       DEX_CONTEXT: 'safe-shell',
@@ -82,13 +84,14 @@ export async function runSafeShellCommand() {
     console.log('Proyecto : ' + projectRoot);
     console.log('Seguro   : ' + safeProjectDir);
     console.log('Modulos  : ' + nodeModulesDir);
+    console.log('Shell    : ' + interactiveShell.shellName + ' interactiva');
     console.log('Nota     : ' + reason);
     console.log('Usa node, npm o npm run desde aqui.');
     console.log('Esta shell abre la copia segura del proyecto dentro de HOME.');
     console.log('Escribe exit para volver a tu shell normal.');
     console.log('');
 
-    await openSafeShell(shell, safeProjectDir, {
+    await openSafeShell(interactiveShell, safeProjectDir, {
       PATH: nextPath,
       DEX_CONTEXT: 'safe-shell',
       DEX_SAFE_PROJECT: projectRoot,
@@ -118,6 +121,7 @@ export async function runSafeShellCommand() {
     console.log('Proyecto : ' + projectRoot);
     console.log('Seguro   : ' + safeProjectDir);
     console.log('Vendor   : ' + vendorDir);
+    console.log('Shell    : ' + interactiveShell.shellName + ' interactiva');
     console.log('Nota     : ' + reason);
     console.log('Usa php, composer o binarios de vendor/bin desde aqui.');
     console.log('Esta shell abre la copia segura del proyecto dentro de HOME.');
@@ -126,7 +130,7 @@ export async function runSafeShellCommand() {
 
     await fs.mkdir(composerHome, { recursive: true });
 
-    await openSafeShell(shell, safeProjectDir, {
+    await openSafeShell(interactiveShell, safeProjectDir, {
       PATH: nextPath,
       COMPOSER_HOME: composerHome,
       DEX_CONTEXT: 'safe-shell',
@@ -171,9 +175,9 @@ function supportsSafeMode(projectType) {
   return projectType === 'python' || projectType === 'node' || projectType === 'php';
 }
 
-function openSafeShell(shell, cwd, envPatch) {
+function openSafeShell(interactiveShell, cwd, envPatch) {
   return new Promise((resolve, reject) => {
-    const child = spawn(shell, ['-i'], {
+    const child = spawn(interactiveShell.shellPath, interactiveShell.shellArgs, {
       cwd,
       stdio: 'inherit',
       env: {

package/src/commands/version.js

@@ -0,0 +1,98 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const PACKAGE_NAME = 'dex-termux-cli';
+const PACKAGE_PATH = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'package.json');
+const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+
+export async function runVersionCommand() {
+  const localPackage = await readLocalPackage();
+  const localVersion = localPackage.version || 'desconocida';
+
+  console.log('Dex Version');
+  console.log('');
+  console.log('Paquete : ' + (localPackage.name || PACKAGE_NAME));
+  console.log('Local   : ' + localVersion);
+
+  const latest = await readLatestPublishedVersion();
+
+  if (!latest) {
+    console.log('npm     : no pude consultar la version publicada ahora mismo');
+    return;
+  }
+
+  console.log('npm     : ' + latest.version);
+
+  const comparison = compareVersions(localVersion, latest.version);
+
+  if (comparison < 0) {
+    console.log('Estado  : hay una version mas nueva publicada');
+    console.log('Accion  : npm i -g ' + PACKAGE_NAME);
+    return;
+  }
+
+  if (comparison > 0) {
+    console.log('Estado  : esta copia local va por delante de npm');
+    return;
+  }
+
+  console.log('Estado  : local y npm estan alineados');
+}
+
+async function readLocalPackage() {
+  const raw = await fs.readFile(PACKAGE_PATH, 'utf8');
+  return JSON.parse(raw);
+}
+
+async function readLatestPublishedVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 2500);
+    const response = await fetch(REGISTRY_URL, {
+      headers: { accept: 'application/json' },
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeout);
+
+    if (!response.ok) {
+      return null;
+    }
+
+    const data = await response.json();
+    return {
+      version: data.version || 'desconocida',
+    };
+  } catch {
+    return null;
+  }
+}
+
+function compareVersions(left, right) {
+  const leftParts = normalizeVersion(left);
+  const rightParts = normalizeVersion(right);
+  const maxLength = Math.max(leftParts.length, rightParts.length);
+
+  for (let index = 0; index < maxLength; index += 1) {
+    const leftValue = leftParts[index] || 0;
+    const rightValue = rightParts[index] || 0;
+
+    if (leftValue > rightValue) {
+      return 1;
+    }
+
+    if (leftValue < rightValue) {
+      return -1;
+    }
+  }
+
+  return 0;
+}
+
+function normalizeVersion(version) {
+  return String(version)
+    .split('.')
+    .map((part) => Number.parseInt(part.replace(/[^0-9].*$/, ''), 10))
+    .filter((part) => Number.isInteger(part));
+}

package/src/core/args.js

@@ -17,6 +17,21 @@ export function parseArgs(argv) {
       continue;
     }
 
+    if (token === '-v' || token === '--version' || token === 'version') {
+      parsed.command = 'version';
+      continue;
+    }
+
+    if (token === '-c' || token === '--context' || token === 'context') {
+      parsed.command = 'context';
+      continue;
+    }
+
+    if (token === '--prompt-context') {
+      parsed.command = 'prompt-context';
+      continue;
+    }
+
     if (token === '-m' || token === '--menu' || token === 'menu') {
       parsed.command = 'menu';
       continue;

package/src/core/config.js

@@ -7,6 +7,9 @@ const DEFAULT_CONFIG = {
     projectBadge: false,
     smartProjectInstall: false,
   },
+  ui: {
+    promptContextPosition: 'right',
+  },
   projects: {},
 };
 
@@ -55,6 +58,19 @@ export async function setFeatureEnabled(featureKey, enabled) {
   return saveUserConfig(nextConfig);
 }
 
+export async function setPromptContextPosition(position) {
+  const config = await loadUserConfig();
+  const nextConfig = {
+    ...config,
+    ui: {
+      ...config.ui,
+      promptContextPosition: normalizePromptContextPosition(position),
+    },
+  };
+
+  return saveUserConfig(nextConfig);
+}
+
 export async function saveProjectState(projectKey, projectState) {
   const config = await loadUserConfig();
   const nextConfig = {
@@ -103,6 +119,11 @@ function mergeConfig(config) {
 
   return {
     features,
+    ui: {
+      ...DEFAULT_CONFIG.ui,
+      ...(config.ui || {}),
+      promptContextPosition: normalizePromptContextPosition(config.ui?.promptContextPosition),
+    },
     projects: {
       ...DEFAULT_CONFIG.projects,
       ...(config.projects || {}),
@@ -115,8 +136,15 @@ function cloneDefaultConfig() {
     features: {
       ...DEFAULT_CONFIG.features,
     },
+    ui: {
+      ...DEFAULT_CONFIG.ui,
+    },
     projects: {
       ...DEFAULT_CONFIG.projects,
     },
   };
 }
+
+function normalizePromptContextPosition(position) {
+  return ['right', 'inline', 'off'].includes(position) ? position : DEFAULT_CONFIG.ui.promptContextPosition;
+}

package/src/ui/output.js

@@ -1,68 +1,62 @@
 import path from 'node:path';
 import { getUserConfigPath } from '../core/config.js';
 
+const ANSI = {
+  bold: '\x1b[1m',
+  cyan: '\x1b[36m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  reset: '\x1b[0m',
+};
+
 export function printHelp() {
-  console.log('Dex CLI');
-  console.log('');
-  console.log('Acciones principales:');
-  console.log('  dex -h                ver ayuda');
-  console.log('  dex -m                abrir menu');
-  console.log('  dex -e ls             explicar un comando');
-  console.log('  dex -b "archivo"      buscar por nombre');
-  console.log('  dex -t src            ver arbol guiado');
-  console.log('  dex -a                abrir Android directo');
-  console.log('  dex -i                instalar dependencias del proyecto');
-  console.log('  dex -r                abrir shell del modo seguro');
-  console.log('');
-  console.log('Busqueda:');
-  console.log('  dex -b "foto"');
-  console.log('  dex -b "*.js" --scope actual');
-  console.log('  Dex -b "whatsapp" --scope android');
-  console.log('');
-  console.log('Arbol:');
-  console.log('  dex -t');
-  console.log('  dex -t src --scope actual');
-  console.log('  dex -t . --depth 3');
-  console.log('');
-  console.log('Android:');
-  console.log('  dex -a');
-  console.log('  activar en: ' + getUserConfigPath());
-  console.log('');
-  console.log('Instalacion segura de proyectos:');
-  console.log('  dex -i');
-  console.log('  detecta el lenguaje del proyecto actual');
-  console.log('  intenta instalar dependencias segun el lenguaje');
-  console.log('  si falta el runtime intenta traerlo con pkg');
-  console.log('  en Android storage ya existe modo seguro para Python, Node y PHP');
-  console.log('');
-  console.log('Modo seguro:');
-  console.log('  dex -r');
-  console.log('  abre una shell del entorno seguro del proyecto actual');
-  console.log('  en Python usa el venv seguro; en Node y PHP abre la copia segura en HOME');
+  printBanner();
   console.log('');
-  console.log('Extras visuales:');
-  console.log('  detector de proyecto por carpeta actual');
-  console.log('  badge de lenguaje con color');
-  console.log('  activar en Ajustes y funciones');
+  console.log('  Explorar, entender y preparar proyectos desde Termux y Android storage.');
   console.log('');
-  console.log('Scopes:');
-  console.log('  actual    carpeta donde estas parado');
-  console.log('  home      tu entorno de Termux');
-  console.log('  android   /sdcard y almacenamiento accesible');
-  console.log('');
-  console.log('Atajos:');
-  console.log('  -h, --help');
-  console.log('  -m, --menu');
-  console.log('  -e, --explicar');
-  console.log('  -b, --buscar');
-  console.log('  -t, --tree');
-  console.log('  -a, --android');
-  console.log('  -i, --instalar');
-  console.log('  -r, --seguro');
-  console.log('  -s, --scope');
-  console.log('  -d, --depth');
-  console.log('');
-  console.log('Nota: si no pasas --scope en busqueda o tree, Dex te pregunta antes.');
+
+  printBlock('Comandos principales', [
+    'dex -m              menu visual',
+    'dex -v              version local y publicada',
+    'dex -c              contexto del proyecto actual',
+    'dex -b "archivo"    buscar archivos o carpetas',
+    'dex -e ls           explicar un comando',
+    'dex -t src          arbol guiado de una ruta',
+    'dex -i              instalar dependencias del proyecto',
+    'dex -r              abrir modo seguro del proyecto',
+    'dex -a              acceso rapido a Android',
+  ]);
+
+  printBlock('Uso rapido', [
+    'dex -b "*.js" --scope actual',
+    'dex -t . --depth 3',
+    'dex -c',
+    'dex --prompt-context',
+  ]);
+
+  printBlock('Scopes', [
+    'actual              carpeta donde estas parado',
+    'home                tu HOME de Termux',
+    'android             almacenamiento accesible',
+  ]);
+
+  printBlock('Atajos', [
+    '-h --help           ayuda',
+    '-v --version        version',
+    '-c --context        contexto',
+    '-m --menu           menu',
+    '-b --buscar         buscar',
+    '-e --explicar       explicar',
+    '-t --tree           arbol',
+    '-i --instalar       instalar',
+    '-r --seguro         shell segura',
+    '-a --android        Android',
+    '-s --scope          scope',
+    '-d --depth          profundidad',
+  ]);
+
+  console.log(dim('Configuracion: ' + getUserConfigPath()));
+  console.log(dim('Nota: si no pasas --scope en busqueda o tree, Dex te pregunta antes.'));
 }
 
 export function printSection(title) {
@@ -127,3 +121,32 @@ export function formatTreeReport(report) {
 
   return lines.join('\n');
 }
+
+function printBanner() {
+  if (!process.stdout.isTTY) {
+    console.log('Dex CLI');
+    return;
+  }
+
+  console.log(ANSI.bold + ANSI.cyan + 'Dex CLI' + ANSI.reset);
+  console.log(dim('────────────────────────────────────────'));
+}
+
+function printBlock(title, lines) {
+  const heading = process.stdout.isTTY ? ANSI.bold + ANSI.green + '[' + title + ']' + ANSI.reset : '[' + title + ']';
+  console.log(heading);
+
+  for (const line of lines) {
+    console.log('  ' + line);
+  }
+
+  console.log('');
+}
+
+function dim(text) {
+  if (!process.stdout.isTTY) {
+    return text;
+  }
+
+  return ANSI.dim + text + ANSI.reset;
+}

package/src/ui/prompt.js

@@ -4,14 +4,18 @@ import { stdin as input, stdout as output } from 'node:process';
 
 const ANSI = {
   clearDown: '\x1B[0J',
+  cyan: '\x1B[36m',
+  dim: '\x1B[2m',
   green: '\x1B[32m',
   red: '\x1B[31m',
   reset: '\x1B[0m',
+  yellow: '\x1B[33m',
+  bold: '\x1B[1m',
 };
 
 export async function chooseSearchScope(options) {
   return chooseNumericOption({
-    title: 'Elige donde quieres buscar:',
+    title: 'Elige donde quieres buscar',
     options,
     getValue: (option) => option.key,
     getLines: (option) => [option.label, option.description, option.root],
@@ -25,7 +29,7 @@ export async function chooseExplainTopic(entries) {
   const topics = Object.keys(entries).map((topic) => ({ topic }));
 
   return chooseNumericOption({
-    title: 'Elige un comando para explicar:',
+    title: 'Elige un comando para explicar',
     options: topics,
     getValue: (option) => option.topic,
     getLines: (option) => [option.topic],
@@ -37,23 +41,27 @@ export async function chooseExplainTopic(entries) {
 
 export async function chooseMenuAction() {
   const options = [
-    { key: 'search', label: 'Buscar archivos o carpetas' },
-    { key: 'explain', label: 'Explicar un comando' },
-    { key: 'tree', label: 'Ver arbol de una ruta' },
-    { key: 'safe-shell', label: 'Entrar al modo seguro del proyecto' },
-    { key: 'settings', label: 'Ajustes y funciones' },
-    { key: 'help', label: 'Ver ayuda' },
-    { key: 'exit', label: 'Salir' },
+    { key: 'search', label: 'Buscar archivos o carpetas', hint: 'encuentra rapido por nombre o patron' },
+    { key: 'explain', label: 'Explicar un comando', hint: 'resume uso, riesgo y notas' },
+    { key: 'tree', label: 'Ver arbol de una ruta', hint: 'muestra carpetas y archivos con profundidad guiada' },
+    { key: 'safe-shell', label: 'Entrar al modo seguro', hint: 'abre el proyecto con el entorno correcto' },
+    { key: 'version', label: 'Ver version de Dex', hint: 'compara local contra la version publicada' },
+    { key: 'context', label: 'Ver contexto del proyecto', hint: 'detecta el lenguaje del proyecto actual' },
+    { key: 'settings', label: 'Ajustes y funciones', hint: 'activa extras y mueve el badge del prompt' },
+    { key: 'help', label: 'Ver ayuda', hint: 'muestra comandos y ejemplos' },
+    { key: 'exit', label: 'Salir', hint: 'cerrar el menu' },
   ];
 
   return chooseNumericOption({
     title: 'Dex Menu',
     options,
     getValue: (option) => option.key,
-    getLines: (option) => [option.label],
+    getLines: (option) => [option.label, option.hint],
     prompt: 'Opcion [1-' + options.length + ', Enter=1]: ',
-    errorMessage: 'Opcion no valida. Usa un numero entre 1 y 7.',
+    errorMessage: 'Opcion no valida. Usa un numero entre 1 y 9.',
     directMatch: (answer) => options.find((option) => option.key === answer.toLowerCase())?.key,
+    style: 'card',
+    introLines: ['Centro rapido para navegar, revisar version y entrar al modo seguro.'],
   });
 }
 
@@ -69,7 +77,13 @@ export async function chooseSettingsAction(config) {
       key: 'toggle-project-badge',
       label: 'Detector de proyecto y color',
       status: formatStatus(config.features.projectBadge),
-      usage: 'muestra lenguaje y color del proyecto',
+      usage: 'muestra lenguaje y color dentro de Dex',
+    },
+    {
+      key: 'prompt-context-position',
+      label: 'Posicion del contexto del prompt',
+      status: formatPromptPosition(config.ui?.promptContextPosition || 'right'),
+      usage: 'elige derecha, inline junto a la ruta o desactivado',
     },
     {
       key: 'toggle-smart-project-install',
@@ -99,9 +113,55 @@ export async function chooseSettingsAction(config) {
       ];
     },
     prompt: 'Ajuste [1-' + options.length + ', Enter=1]: ',
+    errorMessage: 'Opcion no valida. Usa 1, 2, 3, 4 o 5.',
+    directMatch: (answer) => options.find((option) => option.key === answer.toLowerCase())?.key,
+    style: 'card',
+    introLines: ['Activa solo lo que quieras ver todos los dias.'],
+  });
+}
+
+export async function choosePromptContextPosition(currentPosition) {
+  const options = [
+    {
+      key: 'right',
+      label: 'Derecha del prompt',
+      usage: 'muestra [PYTHON] o [NODE] en la esquina derecha',
+    },
+    {
+      key: 'inline',
+      label: 'Inline junto a la ruta',
+      usage: 'muestra Dex@android /ruta [PYTHON] en la misma linea',
+    },
+    {
+      key: 'off',
+      label: 'Ocultar contexto',
+      usage: 'no muestra badge del proyecto en el prompt',
+    },
+    {
+      key: 'back',
+      label: 'Volver',
+    },
+  ];
+
+  return chooseNumericOption({
+    title: 'Posicion del contexto del prompt',
+    options,
+    getValue: (option) => option.key,
+    getLines: (option) => {
+      if (option.key === 'back') {
+        return [option.label];
+      }
+
+      return [
+        option.label,
+        'Uso    : ' + option.usage,
+      ];
+    },
+    prompt: 'Posicion [1-' + options.length + ', Enter=1]: ',
     errorMessage: 'Opcion no valida. Usa 1, 2, 3 o 4.',
     directMatch: (answer) => options.find((option) => option.key === answer.toLowerCase())?.key,
     style: 'card',
+    introLines: ['Actual: ' + formatPromptPosition(currentPosition)],
   });
 }
 
@@ -202,7 +262,7 @@ async function chooseNumericOption({
         return selectedValue;
       }
 
-      console.log(errorMessage);
+      console.log(colorize(errorMessage, 'red'));
     }
   } finally {
     rl.close();
@@ -210,11 +270,12 @@ async function chooseNumericOption({
 }
 
 function printOptionBlock(title, options, getLines, style, introLines) {
-  console.log(title);
+  console.log(colorize(title, 'cyan', 'bold'));
+  console.log(colorize('────────────────────────────────────────', 'dim'));
   console.log('');
 
   for (const line of introLines) {
-    console.log(line);
+    console.log(colorize(line, 'dim'));
   }
 
   if (introLines.length) {
@@ -225,10 +286,10 @@ function printOptionBlock(title, options, getLines, style, introLines) {
     const lines = getLines(option);
 
     if (style === 'card') {
-      console.log('[' + (index + 1) + '] ' + lines[0]);
+      console.log(colorize('[' + (index + 1) + ']', 'yellow', 'bold') + ' ' + lines[0]);
 
       for (let lineIndex = 1; lineIndex < lines.length; lineIndex += 1) {
-        console.log('    - ' + lines[lineIndex]);
+        console.log('    ' + colorize('•', 'dim') + ' ' + lines[lineIndex]);
       }
 
       console.log('');
@@ -242,12 +303,12 @@ function printOptionBlock(title, options, getLines, style, introLines) {
     }
   });
 
-  console.log('Tip: puedes escribir el numero o el nombre corto cuando aplique.');
+  console.log(colorize('Tip: puedes escribir el numero o el nombre corto cuando aplique.', 'dim'));
   console.log('');
 }
 
 function countRenderedLines(options, getLines, introLines, style) {
-  let count = 2 + introLines.length;
+  let count = 3 + introLines.length;
 
   if (introLines.length) {
     count += 1;
@@ -294,6 +355,37 @@ function formatStatus(enabled) {
     return text;
   }
 
-  const color = enabled ? ANSI.green : ANSI.red;
-  return color + text + ANSI.reset;
+  const color = enabled ? 'green' : 'red';
+  return colorize(text, color, 'bold');
+}
+
+function formatPromptPosition(position) {
+  if (position === 'inline') {
+    return 'inline';
+  }
+
+  if (position === 'off') {
+    return 'oculto';
+  }
+
+  return 'derecha';
+}
+
+function colorize(text, color, weight = '') {
+  if (!output.isTTY) {
+    return text;
+  }
+
+  const parts = [];
+
+  if (weight && ANSI[weight]) {
+    parts.push(ANSI[weight]);
+  }
+
+  if (color && ANSI[color]) {
+    parts.push(ANSI[color]);
+  }
+
+  parts.push(text, ANSI.reset);
+  return parts.join('');
 }

package/src/utils/project-context.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 const COLORS = {
   reset: '\x1b[0m',
   python: '\x1b[34m',
-  node: '\x1b[31m',
+  node: '\x1b[32m',
   rust: '\x1b[33m',
   go: '\x1b[36m',
   java: '\x1b[35m',
@@ -13,6 +13,16 @@ const COLORS = {
   generic: '\x1b[92m',
 };
 
+const LANGUAGE_META = {
+  python: { label: 'PYTHON' },
+  node: { label: 'NODE' },
+  rust: { label: 'RUST' },
+  go: { label: 'GO' },
+  java: { label: 'JAVA' },
+  php: { label: 'PHP' },
+  ruby: { label: 'RUBY' },
+};
+
 export async function detectProjectContext(cwd = process.cwd()) {
   const entries = await safeReadDir(cwd);
   if (!entries.length) {
@@ -26,31 +36,31 @@ export async function detectProjectContext(cwd = process.cwd()) {
   const hasRubyFiles = entries.some((entry) => !entry.isDirectory() && entry.name.endsWith('.rb'));
 
   if (names.has('pyproject.toml') || names.has('requirements.txt') || names.has('Pipfile') || names.has('setup.py') || hasPyFiles) {
-    return createContext('python', cwd, 'PYTHON');
+    return createContext('python', cwd, await detectPythonVersion(cwd));
   }
 
   if (names.has('package.json') || names.has('node_modules') || hasJsFiles) {
-    return createContext('node', cwd, 'NODE');
+    return createContext('node', cwd, await detectNodeVersion(cwd));
   }
 
   if (names.has('Cargo.toml')) {
-    return createContext('rust', cwd, 'RUST');
+    return createContext('rust', cwd, await detectRustVersion(cwd));
   }
 
   if (names.has('go.mod')) {
-    return createContext('go', cwd, 'GO');
+    return createContext('go', cwd, await detectGoVersion(cwd));
   }
 
   if (names.has('pom.xml') || names.has('build.gradle') || names.has('build.gradle.kts')) {
-    return createContext('java', cwd, 'JAVA');
+    return createContext('java', cwd, await detectJavaVersion(cwd));
   }
 
   if (names.has('composer.json') || hasPhpFiles) {
-    return createContext('php', cwd, 'PHP');
+    return createContext('php', cwd, await detectPhpVersion(cwd));
   }
 
   if (names.has('Gemfile') || hasRubyFiles) {
-    return createContext('ruby', cwd, 'RUBY');
+    return createContext('ruby', cwd, await detectRubyVersion(cwd));
   }
 
   return null;
@@ -58,15 +68,131 @@ export async function detectProjectContext(cwd = process.cwd()) {
 
 export function formatProjectContext(context) {
   const folderName = path.basename(context.cwd) || context.cwd;
+  const segment = buildContextSegment(context);
   const badge = process.stdout.isTTY
-    ? `${COLORS[context.type] || COLORS.generic}[${context.label}]${COLORS.reset}`
-    : `[${context.label}]`;
+    ? `${COLORS[context.type] || COLORS.generic}[${segment}]${COLORS.reset}`
+    : `[${segment}]`;
 
   return `Contexto: ${folderName} ${badge}`;
 }
 
-function createContext(type, cwd, label) {
-  return { type, cwd, label };
+export function formatPromptContext(context) {
+  return buildContextSegment(context);
+}
+
+export function formatProjectContextDetails(context) {
+  return [
+    'Carpeta : ' + context.cwd,
+    'Tipo    : ' + context.label,
+    'Version : ' + (context.version || 'sin detectar'),
+    'Prompt  : [' + formatPromptContext(context) + ']',
+  ].join('\n');
+}
+
+function createContext(type, cwd, version) {
+  const meta = LANGUAGE_META[type] || { label: type.toUpperCase() };
+  return {
+    type,
+    cwd,
+    label: meta.label,
+    version,
+  };
+}
+
+function buildContextSegment(context) {
+  return context.label;
+}
+
+async function detectPythonVersion(cwd) {
+  const pythonVersionFile = await readFileIfExists(path.join(cwd, '.python-version'));
+  const pipfile = await readFileIfExists(path.join(cwd, 'Pipfile'));
+  const pyproject = await readFileIfExists(path.join(cwd, 'pyproject.toml'));
+  const venvConfig = await readFileIfExists(path.join(cwd, '.venv', 'pyvenv.cfg'));
+  const runtime = await readFileIfExists(path.join(cwd, 'runtime.txt'));
+
+  return compactVersion(
+    firstNonEmptyLine(pythonVersionFile) ||
+    matchVersion(pipfile, /python_version\s*=\s*["']([^"']+)["']/i) ||
+    matchVersion(pyproject, /requires-python\s*=\s*["']([^"']+)["']/i) ||
+    matchVersion(venvConfig, /^version\s*=\s*(.+)$/im) ||
+    matchVersion(runtime, /python-([^\s]+)/i),
+  );
+}
+
+async function detectNodeVersion(cwd) {
+  const nvmrc = await readFileIfExists(path.join(cwd, '.nvmrc'));
+  const nodeVersionFile = await readFileIfExists(path.join(cwd, '.node-version'));
+  const packageJsonRaw = await readFileIfExists(path.join(cwd, 'package.json'));
+
+  try {
+    if (packageJsonRaw) {
+      const packageJson = JSON.parse(packageJsonRaw);
+      return compactVersion(
+        firstNonEmptyLine(nvmrc) ||
+        firstNonEmptyLine(nodeVersionFile) ||
+        packageJson.engines?.node,
+      );
+    }
+  } catch {
+    return compactVersion(firstNonEmptyLine(nvmrc) || firstNonEmptyLine(nodeVersionFile));
+  }
+
+  return compactVersion(firstNonEmptyLine(nvmrc) || firstNonEmptyLine(nodeVersionFile));
+}
+
+async function detectPhpVersion(cwd) {
+  const composerRaw = await readFileIfExists(path.join(cwd, 'composer.json'));
+
+  try {
+    if (composerRaw) {
+      const composer = JSON.parse(composerRaw);
+      return compactVersion(composer.require?.php);
+    }
+  } catch {
+    return null;
+  }
+
+  return null;
+}
+
+async function detectGoVersion(cwd) {
+  const goMod = await readFileIfExists(path.join(cwd, 'go.mod'));
+  return compactVersion(matchVersion(goMod, /^go\s+([^\s]+)$/im));
+}
+
+async function detectRustVersion(cwd) {
+  const cargoToml = await readFileIfExists(path.join(cwd, 'Cargo.toml'));
+  const toolchain = await readFileIfExists(path.join(cwd, 'rust-toolchain'));
+  const toolchainToml = await readFileIfExists(path.join(cwd, 'rust-toolchain.toml'));
+
+  return compactVersion(
+    matchVersion(cargoToml, /rust-version\s*=\s*["']([^"']+)["']/i) ||
+    firstNonEmptyLine(toolchain) ||
+    matchVersion(toolchainToml, /channel\s*=\s*["']([^"']+)["']/i),
+  );
+}
+
+async function detectRubyVersion(cwd) {
+  const rubyVersion = await readFileIfExists(path.join(cwd, '.ruby-version'));
+  const gemfile = await readFileIfExists(path.join(cwd, 'Gemfile'));
+
+  return compactVersion(
+    firstNonEmptyLine(rubyVersion) ||
+    matchVersion(gemfile, /ruby\s+["']([^"']+)["']/i),
+  );
+}
+
+async function detectJavaVersion(cwd) {
+  const pom = await readFileIfExists(path.join(cwd, 'pom.xml'));
+  const gradle = await readFileIfExists(path.join(cwd, 'build.gradle'));
+  const gradleKts = await readFileIfExists(path.join(cwd, 'build.gradle.kts'));
+
+  return compactVersion(
+    matchVersion(pom, /<java.version>([^<]+)<\/java.version>/i) ||
+    matchVersion(pom, /<maven.compiler.release>([^<]+)<\/maven.compiler.release>/i) ||
+    matchVersion(gradle, /sourceCompatibility\s*=\s*['"]?([^\s'"]+)/i) ||
+    matchVersion(gradleKts, /JavaLanguageVersion\.of\((\d+)\)/i),
+  );
 }
 
 async function safeReadDir(directoryPath) {
@@ -77,6 +203,50 @@ async function safeReadDir(directoryPath) {
   }
 }
 
+async function readFileIfExists(filePath) {
+  try {
+    return await fs.readFile(filePath, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function compactVersion(rawValue) {
+  if (!rawValue) {
+    return null;
+  }
+
+  const cleaned = String(rawValue).trim();
+  const versionMatch = cleaned.match(/\d+(?:\.\d+){0,2}/);
+
+  if (versionMatch) {
+    const parts = versionMatch[0].split('.');
+    return parts.slice(0, 2).join('.');
+  }
+
+  return cleaned.slice(0, 10);
+}
+
+function matchVersion(content, expression) {
+  if (!content) {
+    return '';
+  }
+
+  const match = content.match(expression);
+  return match?.[1]?.trim() || '';
+}
+
+function firstNonEmptyLine(content) {
+  if (!content) {
+    return '';
+  }
+
+  return content
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .find(Boolean) || '';
+}
+
 function isNodeScript(name) {
   return name.endsWith('.js') || name.endsWith('.mjs') || name.endsWith('.cjs') || name.endsWith('.ts');
 }

package/src/utils/shell.js

@@ -0,0 +1,54 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const TERMUX_ZSH = '/data/data/com.termux/files/usr/bin/zsh';
+const TERMUX_BASH = '/data/data/com.termux/files/usr/bin/bash';
+const TERMUX_SH = '/data/data/com.termux/files/usr/bin/sh';
+
+export async function resolveInteractiveShell() {
+  const preferredShell = process.env.DEX_PREFERRED_SHELL || process.env.SHELL || '';
+  const candidates = buildShellCandidates(preferredShell);
+
+  for (const shellPath of candidates) {
+    if (!shellPath) {
+      continue;
+    }
+
+    if (await shellExists(shellPath)) {
+      return {
+        shellPath,
+        shellArgs: ['-i'],
+        shellName: path.basename(shellPath),
+      };
+    }
+  }
+
+  return {
+    shellPath: TERMUX_SH,
+    shellArgs: ['-i'],
+    shellName: 'sh',
+  };
+}
+
+function buildShellCandidates(preferredShell) {
+  const shellName = path.basename(preferredShell || '');
+
+  if (preferredShell && shellName && shellName !== 'sh') {
+    return dedupe([preferredShell, TERMUX_ZSH, TERMUX_BASH, TERMUX_SH]);
+  }
+
+  return dedupe([TERMUX_ZSH, TERMUX_BASH, preferredShell, TERMUX_SH]);
+}
+
+async function shellExists(shellPath) {
+  try {
+    await fs.access(shellPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function dedupe(values) {
+  return [...new Set(values.filter(Boolean))];
+}