dex-termux-cli 0.3.0-beta.1 → 0.3.0-beta.3

package/README.md

@@ -35,13 +35,13 @@ Dex mejora tareas comunes de terminal sin tapar el entorno real. Sirve para expl
 - `dex -b`: busqueda guiada
 - `dex -e`: explicacion de comandos comunes
 - `dex -t`: tree guiado
-- `dex -a`: shell redisenada para Android storage en modo Termux
+- `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 detecta el lenguaje segun los archivos del directorio actual. 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.
+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.
 
 Lenguajes detectables actualmente:
 
@@ -78,7 +78,7 @@ El modo actual se guarda en `~/.config/dex/config.json`.
 ## Estado real de la beta
 
 - `dex -m`, `-a`, `-b`, `-t`, `-v`, `-c` y `--prompt-context` funcionan
-- `dex -a` ahora abre una interfaz Android dedicada con splash, prompt propio y atajos (`shared`, `dl`, `docs`, `dcim`, `pics`, `music`, `movies`)
+- `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

package/package.json

@@ -1,15 +1,20 @@
 {
   "name": "dex-termux-cli",
-  "version": "0.3.0-beta.1",
+  "version": "0.3.0-beta.3",
   "type": "module",
-  "description": "Visual CLI for Termux and Linux with guided search, readable tree views, project context, version checks, and safe 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": [
@@ -38,8 +44,5 @@
   },
   "engines": {
     "node": ">=18"
-  },
-  "dependencies": {
-    "tree": "^0.1.3"
   }
 }

package/src/app/main.js

@@ -11,10 +11,12 @@ 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';
+import { resolvePlatformMode } from '../utils/platform.js';
 
 export async function main(argv = process.argv.slice(2)) {
   const parsed = parseArgs(argv);
   const config = await loadUserConfig();
+  const platformMode = resolvePlatformMode(config);
   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';
@@ -27,7 +29,7 @@ export async function main(argv = process.argv.slice(2)) {
   }
 
   if (parsed.help || !argv.length) {
-    printHelp();
+    printHelp(platformMode);
     return;
   }
 
@@ -91,5 +93,5 @@ export async function main(argv = process.argv.slice(2)) {
     return;
   }
 
-  printHelp();
+  printHelp(platformMode);
 }

package/src/commands/android-shell.js

@@ -1,8 +1,18 @@
 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 { canUseAndroidFeatures, getAndroidStorageRoot, resolvePlatformMode } from '../utils/platform.js';
+import {
+  getQuickAccessAliases,
+  getQuickAccessLabel,
+  getQuickAccessModeDescription,
+  getQuickAccessRoot,
+  getQuickAccessShortcutSummary,
+  getQuickAccessTitle,
+  resolvePlatformMode,
+} from '../utils/platform.js';
 
 const ANDROID_BASH_CANDIDATES = [
   '/data/data/com.termux/files/usr/bin/bash',
@@ -14,63 +24,64 @@ export async function runAndroidShellCommand() {
 
   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);
-
-  if (!canUseAndroidFeatures(platformMode)) {
-    throw new Error('dex -a solo esta disponible en modo Termux/Android. Cambia el modo Linux desde ajustes si quieres evitar esta opcion.');
-  }
-
-  const androidRoot = getAndroidStorageRoot(platformMode);
+  const quickAccessRoot = getQuickAccessRoot(platformMode);
 
   try {
-    await fs.access(androidRoot);
+    await fs.access(quickAccessRoot);
   } catch {
-    throw new Error(`No se puede acceder a la ruta Android: ${androidRoot}`);
+    throw new Error(`No se puede acceder a la ruta base de acceso rapido: ${quickAccessRoot}`);
   }
 
   const interactiveShell = await resolveAndroidInteractiveShell(platformMode);
+  const shellSession = await createQuickAccessShellSession(platformMode, interactiveShell);
 
-  console.log('Dex Android');
+  console.log(getQuickAccessTitle(platformMode));
   console.log('');
-  console.log(`Raiz    : ${androidRoot}`);
+  console.log(`Raiz    : ${quickAccessRoot}`);
   console.log(`Shell   : ${interactiveShell.shellName} interactiva`);
-  console.log('Modo    : interfaz Android redisenada');
-  console.log('Atajos  : dl, docs, dcim, pics, music, movies, shared');
+  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: androidRoot,
-      stdio: 'inherit',
-      env: {
-        ...process.env,
-        DEX_CONTEXT: 'android-shell',
-        DEX_ANDROID_ROOT: androidRoot,
-        DEX_ANDROID_LABEL: 'ANDROID STORAGE',
-        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;
-      }
-
-      if (code && code !== 0) {
-        reject(new Error(`La shell Android termino con codigo ${code}`));
-        return;
-      }
-
-      resolve();
+  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 de acceso rapido termino por senal: ${signal}`));
+          return;
+        }
+
+        if (code && code !== 0) {
+          reject(new Error(`La shell de acceso rapido termino con codigo ${code}`));
+          return;
+        }
+
+        resolve();
+      });
     });
-  });
+  } finally {
+    await shellSession.cleanup();
+  }
 }
 
 async function resolveAndroidInteractiveShell(platformMode) {
@@ -95,3 +106,143 @@ async function resolveAndroidInteractiveShell(platformMode) {
 
   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/menu.js

@@ -27,7 +27,8 @@ export async function runMenuCommand() {
     const action = await chooseMenuAction();
 
     if (action === 'help') {
-      printHelp();
+      const config = await loadUserConfig();
+      printHelp(resolvePlatformMode(config));
       return;
     }
 
@@ -101,8 +102,8 @@ async function runSettingsMenu() {
     if (action === 'toggle-android-shortcut') {
       const toggle = await chooseFeatureToggle(
         config.features.androidShortcut,
-        'Acceso rapido a Android',
-        'permite usar dex -a',
+        'Acceso rapido',
+        'permite usar dex -a en Termux o Linux',
       );
 
       if (toggle === 'back') {
@@ -111,7 +112,7 @@ async function runSettingsMenu() {
 
       const enabled = toggle === 'enable';
       await setFeatureEnabled('androidShortcut', enabled);
-      console.log(`Acceso rapido a Android: ${enabled ? 'activado' : 'desactivado'}.`);
+      console.log(`Acceso rapido: ${enabled ? 'activado' : 'desactivado'}.`);
       console.log('');
       continue;
     }

package/src/commands/version.js

@@ -69,14 +69,14 @@ async function readLatestPublishedVersion() {
   }
 }
 
-function compareVersions(left, right) {
-  const leftParts = normalizeVersion(left);
-  const rightParts = normalizeVersion(right);
-  const maxLength = Math.max(leftParts.length, rightParts.length);
+export function compareVersions(left, right) {
+  const leftVersion = parseSemver(left);
+  const rightVersion = parseSemver(right);
+  const maxLength = Math.max(leftVersion.core.length, rightVersion.core.length);
 
   for (let index = 0; index < maxLength; index += 1) {
-    const leftValue = leftParts[index] || 0;
-    const rightValue = rightParts[index] || 0;
+    const leftValue = leftVersion.core[index] || 0;
+    const rightValue = rightVersion.core[index] || 0;
 
     if (leftValue > rightValue) {
       return 1;
@@ -87,12 +87,85 @@ function compareVersions(left, right) {
     }
   }
 
+  return comparePrerelease(leftVersion.prerelease, rightVersion.prerelease);
+}
+
+function parseSemver(version) {
+  const normalized = String(version).trim();
+  const [mainPart = '', prereleasePart = ''] = normalized.split('-', 2);
+
+  return {
+    core: mainPart
+      .split('.')
+      .map((part) => Number.parseInt(part, 10))
+      .filter((part) => Number.isInteger(part)),
+    prerelease: prereleasePart
+      ? prereleasePart
+        .split('.')
+        .filter(Boolean)
+        .map((part) => (/^\d+$/.test(part) ? Number.parseInt(part, 10) : part.toLowerCase()))
+      : [],
+  };
+}
+
+function comparePrerelease(left, right) {
+  const leftHasPrerelease = left.length > 0;
+  const rightHasPrerelease = right.length > 0;
+
+  if (!leftHasPrerelease && !rightHasPrerelease) {
+    return 0;
+  }
+
+  if (!leftHasPrerelease) {
+    return 1;
+  }
+
+  if (!rightHasPrerelease) {
+    return -1;
+  }
+
+  const maxLength = Math.max(left.length, right.length);
+
+  for (let index = 0; index < maxLength; index += 1) {
+    const leftPart = left[index];
+    const rightPart = right[index];
+
+    if (leftPart === undefined) {
+      return -1;
+    }
+
+    if (rightPart === undefined) {
+      return 1;
+    }
+
+    const comparison = comparePrereleasePart(leftPart, rightPart);
+    if (comparison !== 0) {
+      return comparison;
+    }
+  }
+
   return 0;
 }
 
-function normalizeVersion(version) {
-  return String(version)
-    .split('.')
-    .map((part) => Number.parseInt(part.replace(/[^0-9].*$/, ''), 10))
-    .filter((part) => Number.isInteger(part));
+function comparePrereleasePart(left, right) {
+  const leftIsNumber = typeof left === 'number';
+  const rightIsNumber = typeof right === 'number';
+
+  if (leftIsNumber && rightIsNumber) {
+    return left === right ? 0 : left > right ? 1 : -1;
+  }
+
+  if (leftIsNumber) {
+    return -1;
+  }
+
+  if (rightIsNumber) {
+    return 1;
+  }
+
+  if (left === right) {
+    return 0;
+  }
+
+  return left > right ? 1 : -1;
 }

package/src/core/args.js

@@ -47,7 +47,7 @@ export function parseArgs(argv) {
       continue;
     }
 
-    if (token === '-b' || token === '--buscar') {
+    if (token === '-b' || token === '--buscar' || token === '--search' || token === 'search') {
       parsed.command = 'search';
       const next = argv[index + 1];
       if (next && !next.startsWith('-')) {
@@ -57,7 +57,7 @@ export function parseArgs(argv) {
       continue;
     }
 
-    if (token === '-e' || token === '--explicar' || token === 'explicar') {
+    if (token === '-e' || token === '--explicar' || token === '--explain' || token === 'explicar' || token === 'explain') {
       parsed.command = 'explain';
       const next = argv[index + 1];
       if (next && !next.startsWith('-')) {
@@ -87,7 +87,7 @@ export function parseArgs(argv) {
       continue;
     }
 
-    if (token === '-r' || token === '--seguro' || token === '--safe-shell' || token === 'seguro') {
+    if (token === '-r' || token === '--seguro' || token === '--safe-shell' || token === 'seguro' || token === 'safe-shell') {
       parsed.command = 'safe-shell';
       continue;
     }

package/src/core/config.js

@@ -4,8 +4,8 @@ import { getHomeDirectory, normalizePlatformMode } from '../utils/platform.js';
 
 const DEFAULT_CONFIG = {
   features: {
-    androidShortcut: false,
-    projectBadge: false,
+    androidShortcut: true,
+    projectBadge: true,
     smartProjectInstall: false,
   },
   ui: {
@@ -82,13 +82,14 @@ export async function setPlatformMode(platformMode) {
   };
 
   if (normalized === 'linux') {
-    nextFeatures.androidShortcut = false;
+    nextFeatures.androidShortcut = true;
     nextFeatures.projectBadge = true;
     nextFeatures.smartProjectInstall = true;
   }
 
   if (normalized === 'termux') {
     nextFeatures.androidShortcut = true;
+    nextFeatures.projectBadge = true;
   }
 
   return saveUserConfig({

package/src/core/scopes.js

@@ -30,6 +30,16 @@ export function getScopeOptions(platformMode) {
       root: getAndroidStorageRoot(platformMode),
       description: 'Busca dentro del almacenamiento compartido accesible.',
     });
+  } else {
+    const sharedRoot = getAndroidStorageRoot(platformMode);
+    if (sharedRoot) {
+      options.push({
+        key: 'shared',
+        label: 'Almacenamiento compartido',
+        root: sharedRoot,
+        description: 'Busca dentro del almacenamiento compartido montado en Linux.',
+      });
+    }
   }
 
   return options;

package/src/ui/output.js

@@ -1,5 +1,7 @@
 import path from 'node:path';
 import { getUserConfigPath } from '../core/config.js';
+import { getScopeOptions } from '../core/scopes.js';
+import { isHostTermux } from '../utils/platform.js';
 
 const ANSI = {
   bold: '\x1b[1m',
@@ -9,7 +11,7 @@ const ANSI = {
   reset: '\x1b[0m',
 };
 
-export function printHelp() {
+export function printHelp(platformMode = '') {
   printBanner();
   console.log('');
   console.log('  Explorar, entender y preparar proyectos desde Termux o Linux.');
@@ -25,7 +27,7 @@ export function printHelp() {
     'dex -t src          arbol guiado de una ruta',
     'dex -i              instalar dependencias del proyecto detectado',
     'dex -r              abrir modo seguro del proyecto (Py/Node/PHP/Ruby/Go/Rust/Java)',
-    'dex -a              acceso rapido a Android',
+    'dex -a              acceso rapido a Android o Linux',
   ]);
 
   printBlock('Uso rapido', [
@@ -33,14 +35,12 @@ export function printHelp() {
     'dex -t . --depth 3 --scope actual',
     'dex -c',
     'dex --prompt-context',
-    'dex-project-context --root',
+    'dex --prompt-project-root',
+    'dex --prompt-project-path',
   ]);
 
-  printBlock('Scopes', [
-    'actual              carpeta donde estas parado',
-    'home                tu HOME del entorno actual',
-    'android             almacenamiento accesible en modo Termux',
-  ]);
+  const scopeOptions = getScopeOptions(platformMode || (isHostTermux() ? 'termux' : 'linux'));
+  printBlock('Scopes', scopeOptions.map((option) => `${option.key.padEnd(19, ' ')}${option.description}`));
 
   printBlock('Atajos', [
     '-h --help           ayuda',

package/src/ui/prompt.js

@@ -75,9 +75,9 @@ export async function chooseSettingsAction(config) {
     },
     {
       key: 'toggle-android-shortcut',
-      label: 'Acceso rapido a Android',
+      label: 'Acceso rapido',
       status: formatStatus(config.features.androidShortcut),
-      usage: 'permite dex -a en Termux',
+      usage: 'permite dex -a en Termux o Linux',
     },
     {
       key: 'toggle-project-badge',

package/src/utils/platform.js

@@ -1,12 +1,31 @@
+import fs from 'node:fs';
 import path from 'node:path';
 
 const TERMUX_HOME = '/data/data/com.termux/files/home';
 const ANDROID_STORAGE = '/sdcard';
+const SHARED_STORAGE_CANDIDATES = [
+  '/storage/emulated/0',
+  '/sdcard',
+];
 
 export function getHomeDirectory() {
   return process.env.HOME || TERMUX_HOME;
 }
 
+export function getSharedStorageRoot() {
+  for (const candidate of SHARED_STORAGE_CANDIDATES) {
+    try {
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  return '';
+}
+
 export function isHostTermux() {
   const home = getHomeDirectory();
   return Boolean(process.env.TERMUX_VERSION) || home === TERMUX_HOME || home.startsWith(TERMUX_HOME + path.sep);
@@ -53,7 +72,73 @@ export function canUseAndroidFeatures(platformMode) {
 }
 
 export function getAndroidStorageRoot(platformMode) {
-  return canUseAndroidFeatures(platformMode) ? ANDROID_STORAGE : '';
+  if (canUseAndroidFeatures(platformMode)) {
+    return ANDROID_STORAGE;
+  }
+
+  return getSharedStorageRoot();
+}
+
+export function getQuickAccessRoot(platformMode) {
+  const sharedStorage = getSharedStorageRoot();
+
+  if (platformMode === 'termux') {
+    return sharedStorage || ANDROID_STORAGE;
+  }
+
+  return sharedStorage || getHomeDirectory();
+}
+
+export function getQuickAccessTitle(platformMode) {
+  return platformMode === 'termux' ? 'Dex Android' : 'Dex Linux';
+}
+
+export function getQuickAccessModeDescription(platformMode) {
+  return platformMode === 'termux'
+    ? 'interfaz Android redisenada'
+    : 'interfaz Linux redisenada';
+}
+
+export function getQuickAccessLabel(platformMode) {
+  if (platformMode === 'termux') {
+    return 'ANDROID STORAGE';
+  }
+
+  return getSharedStorageRoot() ? 'SHARED STORAGE' : 'LINUX HOME';
+}
+
+export function getQuickAccessShortcutSummary(platformMode) {
+  return platformMode === 'termux'
+    ? 'dl, docs, dcim, pics, music, movies, shared'
+    : 'shared, home, dl, docs, desk, pics, music, vids, tmp';
+}
+
+export function getQuickAccessAliases(platformMode) {
+  if (platformMode === 'termux') {
+    return {
+      shared: '/sdcard',
+      dl: '/sdcard/Download',
+      docs: '/sdcard/Documents',
+      dcim: '/sdcard/DCIM',
+      pics: '/sdcard/Pictures',
+      music: '/sdcard/Music',
+      movies: '/sdcard/Movies',
+    };
+  }
+
+  const home = getHomeDirectory();
+  const shared = getSharedStorageRoot() || home;
+  return {
+    home,
+    shared,
+    dl: path.join(shared, 'Download'),
+    docs: path.join(shared, 'Documents'),
+    desk: path.join(home, 'Desktop'),
+    pics: path.join(shared, 'Pictures'),
+    music: path.join(shared, 'Music'),
+    vids: path.join(shared, 'Movies'),
+    tmp: '/tmp',
+  };
 }
 
 export function shouldRestrictProjectToAndroidStorage(platformMode) {

package/src/utils/project-context.js

@@ -24,6 +24,8 @@ const LANGUAGE_META = {
 };
 
 const MAX_PARENT_LOOKUP = 16;
+const MAX_IMPLICIT_SCAN_DEPTH = 3;
+const MAX_IMPLICIT_SCAN_ENTRIES = 160;
 
 export async function detectProjectContext(cwd = process.cwd()) {
   const searchChain = buildSearchChain(cwd);
@@ -63,7 +65,7 @@ export function formatPromptContext(context) {
 }
 
 export function formatPromptProjectRoot(context) {
-  return path.basename(context.projectRoot || context.cwd) || context.cwd;
+  return context.projectRoot || context.cwd;
 }
 
 export function formatPromptProjectPath(context) {
@@ -136,23 +138,68 @@ async function detectProjectContextAt(targetDir, cwd) {
     return createContext('ruby', cwd, targetDir, await detectRubyVersion(targetDir), 'implicit');
   }
 
+  const nestedImplicitType = await detectImplicitLanguageFromTree(targetDir);
+  if (nestedImplicitType) {
+    return createContext(nestedImplicitType, cwd, targetDir, await detectVersionForType(nestedImplicitType, targetDir), 'implicit');
+  }
+
   return null;
 }
 
-function pickBestDetection(detections) {
-  let bestMatch = detections[0];
-
-  for (let index = 1; index < detections.length; index += 1) {
-    const current = detections[index];
+async function detectImplicitLanguageFromTree(rootDir) {
+  const queue = [{ dir: rootDir, depth: 0 }];
+  let visitedEntries = 0;
 
-    if (current.type !== bestMatch.type) {
-      break;
+  while (queue.length && visitedEntries < MAX_IMPLICIT_SCAN_ENTRIES) {
+    const current = queue.shift();
+    const nestedEntries = await safeReadDir(current.dir);
+    if (!nestedEntries.length) {
+      continue;
     }
 
-    bestMatch = current;
+    for (const item of nestedEntries) {
+      visitedEntries += 1;
+
+      if (!item.isDirectory()) {
+        if (item.name.endsWith('.py')) {
+          return 'python';
+        }
+
+        if (isNodeScript(item.name)) {
+          return 'node';
+        }
+
+        if (item.name.endsWith('.php')) {
+          return 'php';
+        }
+
+        if (item.name.endsWith('.rb')) {
+          return 'ruby';
+        }
+
+        continue;
+      }
+
+      if (current.depth + 1 > MAX_IMPLICIT_SCAN_DEPTH) {
+        continue;
+      }
+
+      if (shouldSkipImplicitDirectory(item.name)) {
+        continue;
+      }
+
+      queue.push({
+        dir: path.join(current.dir, item.name),
+        depth: current.depth + 1,
+      });
+    }
   }
 
-  return bestMatch;
+  return '';
+}
+
+function pickBestDetection(detections) {
+  return detections[0];
 }
 
 function createContext(type, cwd, projectRoot, version, detectionKind) {
@@ -279,6 +326,38 @@ async function detectJavaVersion(cwd) {
   );
 }
 
+async function detectVersionForType(type, cwd) {
+  if (type === 'python') {
+    return detectPythonVersion(cwd);
+  }
+
+  if (type === 'node') {
+    return detectNodeVersion(cwd);
+  }
+
+  if (type === 'php') {
+    return detectPhpVersion(cwd);
+  }
+
+  if (type === 'ruby') {
+    return detectRubyVersion(cwd);
+  }
+
+  if (type === 'go') {
+    return detectGoVersion(cwd);
+  }
+
+  if (type === 'rust') {
+    return detectRustVersion(cwd);
+  }
+
+  if (type === 'java') {
+    return detectJavaVersion(cwd);
+  }
+
+  return null;
+}
+
 async function safeReadDir(directoryPath) {
   try {
     return await fs.readdir(directoryPath, { withFileTypes: true });
@@ -334,3 +413,17 @@ function firstNonEmptyLine(content) {
 function isNodeScript(name) {
   return name.endsWith('.js') || name.endsWith('.mjs') || name.endsWith('.cjs') || name.endsWith('.ts');
 }
+
+function shouldSkipImplicitDirectory(name) {
+  return [
+    '.git',
+    '.venv',
+    'node_modules',
+    '__pycache__',
+    '.mypy_cache',
+    '.pytest_cache',
+    '.ruff_cache',
+    'dist',
+    'build',
+  ].includes(name);
+}