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

package/src/commands/safe-shell.js

@@ -5,6 +5,7 @@ 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';
+import { isAndroidStoragePath, resolvePlatformMode, shouldRestrictProjectToAndroidStorage } from '../utils/platform.js';
 
 export async function runSafeShellCommand() {
   const config = await loadUserConfig();
@@ -13,20 +14,23 @@ export async function runSafeShellCommand() {
     throw new Error('La instalacion segura de proyectos esta desactivada. Activa esa funcion antes de abrir el modo seguro.');
   }
 
-  const projectRoot = process.cwd();
+  const currentDir = process.cwd();
   const projectContext = await detectProjectContext();
+  const platformMode = resolvePlatformMode(config);
 
   if (!projectContext || !supportsSafeMode(projectContext.type)) {
-    throw new Error('El modo seguro de Dex por ahora solo existe para proyectos Python, Node y PHP.');
+    throw new Error('El modo seguro de Dex por ahora solo existe para proyectos Python, Node, PHP, Ruby, Go, Rust y Java.');
   }
 
-  if (!isAndroidStoragePath(projectRoot)) {
-    throw new Error('El modo seguro de Dex por ahora se usa en proyectos Python, Node o PHP dentro de Android storage.');
+  const projectRoot = projectContext.projectRoot || currentDir;
+
+  if (shouldRestrictProjectToAndroidStorage(platformMode) && !isAndroidStoragePath(projectRoot)) {
+    throw new Error('El modo seguro de Dex en Termux por ahora se usa en proyectos Python, Node, PHP, Ruby, Go, Rust o Java dentro de Android storage.');
   }
 
   const projectKey = getProjectKey(projectRoot);
   const projectState = config.projects && config.projects[projectKey] ? config.projects[projectKey] : null;
-  const interactiveShell = await resolveInteractiveShell();
+  const interactiveShell = await resolveInteractiveShell(platformMode);
   const reason = projectState && projectState.preferSafeInstall
     ? 'Este proyecto ya quedo marcado para modo seguro.'
     : 'Entrando al entorno seguro manual de Dex.';
@@ -46,6 +50,9 @@ export async function runSafeShellCommand() {
 
     console.log('Modo Dex : shell segura para ' + path.basename(projectRoot));
     console.log('Proyecto : ' + projectRoot);
+    if (currentDir !== projectRoot) {
+      console.log('Desde    : ' + currentDir);
+    }
     console.log('Entorno  : ' + venvDir);
     console.log('Python   : ' + rescuePython);
     console.log('Shell    : ' + interactiveShell.shellName + ' interactiva');
@@ -61,6 +68,9 @@ export async function runSafeShellCommand() {
       DEX_CONTEXT: 'safe-shell',
       DEX_SAFE_PROJECT: projectRoot,
       DEX_SAFE_PROJECT_KEY: projectKey,
+      DEX_SAFE_WORKSPACE: projectRoot,
+      DEX_SAFE_LABEL: 'PYTHON SAFE',
+      DEX_SAFE_RUNTIME: 'python',
     });
     return;
   }
@@ -74,14 +84,18 @@ export async function runSafeShellCommand() {
     try {
       await fs.access(packageJsonPath);
       await fs.access(nodeModulesDir);
+      await ensureSafeWorkspaceMatchesProject(safeProjectDir, projectRoot, projectContext.type);
     } catch {
-      throw new Error('No encontre el espacio seguro de este proyecto Node. Corre dex -i primero para prepararlo.');
+      throw new Error('No encontre un espacio seguro valido para este proyecto Node. Corre dex -i primero para recrearlo.');
     }
 
     const nextPath = nodeBinDir + ':' + (process.env.PATH || '');
 
     console.log('Modo Dex : shell segura para ' + path.basename(projectRoot));
     console.log('Proyecto : ' + projectRoot);
+    if (currentDir !== projectRoot) {
+      console.log('Desde    : ' + currentDir);
+    }
     console.log('Seguro   : ' + safeProjectDir);
     console.log('Modulos  : ' + nodeModulesDir);
     console.log('Shell    : ' + interactiveShell.shellName + ' interactiva');
@@ -97,6 +111,8 @@ export async function runSafeShellCommand() {
       DEX_SAFE_PROJECT: projectRoot,
       DEX_SAFE_PROJECT_KEY: projectKey,
       DEX_SAFE_WORKSPACE: safeProjectDir,
+      DEX_SAFE_LABEL: 'NODE SAFE',
+      DEX_SAFE_RUNTIME: 'node',
     });
     return;
   }
@@ -111,14 +127,18 @@ export async function runSafeShellCommand() {
     try {
       await fs.access(composerJsonPath);
       await fs.access(vendorDir);
+      await ensureSafeWorkspaceMatchesProject(safeProjectDir, projectRoot, projectContext.type);
     } catch {
-      throw new Error('No encontre el espacio seguro de este proyecto PHP. Corre dex -i primero para prepararlo.');
+      throw new Error('No encontre un espacio seguro valido para este proyecto PHP. Corre dex -i primero para recrearlo.');
     }
 
     const nextPath = vendorBinDir + ':' + (process.env.PATH || '');
 
     console.log('Modo Dex : shell segura para ' + path.basename(projectRoot));
     console.log('Proyecto : ' + projectRoot);
+    if (currentDir !== projectRoot) {
+      console.log('Desde    : ' + currentDir);
+    }
     console.log('Seguro   : ' + safeProjectDir);
     console.log('Vendor   : ' + vendorDir);
     console.log('Shell    : ' + interactiveShell.shellName + ' interactiva');
@@ -137,7 +157,154 @@ export async function runSafeShellCommand() {
       DEX_SAFE_PROJECT: projectRoot,
       DEX_SAFE_PROJECT_KEY: projectKey,
       DEX_SAFE_WORKSPACE: safeProjectDir,
+      DEX_SAFE_LABEL: 'PHP SAFE',
+      DEX_SAFE_RUNTIME: 'php',
+    });
+    return;
+  }
+
+  if (projectContext.type === 'ruby') {
+    const safeProjectDir = getSafeProjectWorkspacePath(projectRoot, projectContext.type);
+    const gemfilePath = path.join(safeProjectDir, 'Gemfile');
+
+    try {
+      await fs.access(gemfilePath);
+      await ensureSafeWorkspaceMatchesProject(safeProjectDir, projectRoot, projectContext.type);
+    } catch {
+      throw new Error('No encontre un espacio seguro valido para este proyecto Ruby. Corre dex -i primero para recrearlo.');
+    }
+
+    console.log('Modo Dex : shell segura para ' + path.basename(projectRoot));
+    console.log('Proyecto : ' + projectRoot);
+    if (currentDir !== projectRoot) {
+      console.log('Desde    : ' + currentDir);
+    }
+    console.log('Seguro   : ' + safeProjectDir);
+    console.log('Shell    : ' + interactiveShell.shellName + ' interactiva');
+    console.log('Nota     : ' + reason);
+    console.log('Usa ruby, bundle o bundle exec 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(interactiveShell, safeProjectDir, {
+      DEX_CONTEXT: 'safe-shell',
+      DEX_SAFE_PROJECT: projectRoot,
+      DEX_SAFE_PROJECT_KEY: projectKey,
+      DEX_SAFE_WORKSPACE: safeProjectDir,
+      DEX_SAFE_LABEL: 'RUBY SAFE',
+      DEX_SAFE_RUNTIME: 'ruby',
+    });
+    return;
+  }
+
+  if (projectContext.type === 'go') {
+    const safeProjectDir = getSafeProjectWorkspacePath(projectRoot, projectContext.type);
+    const goModPath = path.join(safeProjectDir, 'go.mod');
+
+    try {
+      await fs.access(goModPath);
+      await ensureSafeWorkspaceMatchesProject(safeProjectDir, projectRoot, projectContext.type);
+    } catch {
+      throw new Error('No encontre un espacio seguro valido para este proyecto Go. Corre dex -i primero para recrearlo.');
+    }
+
+    console.log('Modo Dex : shell segura para ' + path.basename(projectRoot));
+    console.log('Proyecto : ' + projectRoot);
+    if (currentDir !== projectRoot) {
+      console.log('Desde    : ' + currentDir);
+    }
+    console.log('Seguro   : ' + safeProjectDir);
+    console.log('Shell    : ' + interactiveShell.shellName + ' interactiva');
+    console.log('Nota     : ' + reason);
+    console.log('Usa go run, go test o go build 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(interactiveShell, safeProjectDir, {
+      DEX_CONTEXT: 'safe-shell',
+      DEX_SAFE_PROJECT: projectRoot,
+      DEX_SAFE_PROJECT_KEY: projectKey,
+      DEX_SAFE_WORKSPACE: safeProjectDir,
+      DEX_SAFE_LABEL: 'GO SAFE',
+      DEX_SAFE_RUNTIME: 'go',
     });
+    return;
+  }
+
+  if (projectContext.type === 'rust') {
+    const safeProjectDir = getSafeProjectWorkspacePath(projectRoot, projectContext.type);
+    const cargoTomlPath = path.join(safeProjectDir, 'Cargo.toml');
+
+    try {
+      await fs.access(cargoTomlPath);
+      await ensureSafeWorkspaceMatchesProject(safeProjectDir, projectRoot, projectContext.type);
+    } catch {
+      throw new Error('No encontre un espacio seguro valido para este proyecto Rust. Corre dex -i primero para recrearlo.');
+    }
+
+    console.log('Modo Dex : shell segura para ' + path.basename(projectRoot));
+    console.log('Proyecto : ' + projectRoot);
+    if (currentDir !== projectRoot) {
+      console.log('Desde    : ' + currentDir);
+    }
+    console.log('Seguro   : ' + safeProjectDir);
+    console.log('Shell    : ' + interactiveShell.shellName + ' interactiva');
+    console.log('Nota     : ' + reason);
+    console.log('Usa cargo build, cargo test o cargo 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(interactiveShell, safeProjectDir, {
+      DEX_CONTEXT: 'safe-shell',
+      DEX_SAFE_PROJECT: projectRoot,
+      DEX_SAFE_PROJECT_KEY: projectKey,
+      DEX_SAFE_WORKSPACE: safeProjectDir,
+      DEX_SAFE_LABEL: 'RUST SAFE',
+      DEX_SAFE_RUNTIME: 'rust',
+    });
+    return;
+  }
+
+  if (projectContext.type === 'java') {
+    const safeProjectDir = getSafeProjectWorkspacePath(projectRoot, projectContext.type);
+    const pomPath = path.join(safeProjectDir, 'pom.xml');
+    const gradlePath = path.join(safeProjectDir, 'build.gradle');
+    const gradleKtsPath = path.join(safeProjectDir, 'build.gradle.kts');
+
+    try {
+      await ensureSafeWorkspaceMatchesProject(safeProjectDir, projectRoot, projectContext.type);
+      if (!(await hasJavaBuildFiles(pomPath, gradlePath, gradleKtsPath))) {
+        throw new Error('missing-java-build-files');
+      }
+    } catch {
+      throw new Error('No encontre un espacio seguro valido para este proyecto Java. Corre dex -i primero para recrearlo.');
+    }
+
+    console.log('Modo Dex : shell segura para ' + path.basename(projectRoot));
+    console.log('Proyecto : ' + projectRoot);
+    if (currentDir !== projectRoot) {
+      console.log('Desde    : ' + currentDir);
+    }
+    console.log('Seguro   : ' + safeProjectDir);
+    console.log('Shell    : ' + interactiveShell.shellName + ' interactiva');
+    console.log('Nota     : ' + reason);
+    console.log('Usa mvn, ./mvnw, gradle o ./gradlew desde aqui segun el proyecto.');
+    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(interactiveShell, safeProjectDir, {
+      DEX_CONTEXT: 'safe-shell',
+      DEX_SAFE_PROJECT: projectRoot,
+      DEX_SAFE_PROJECT_KEY: projectKey,
+      DEX_SAFE_WORKSPACE: safeProjectDir,
+      DEX_SAFE_LABEL: 'JAVA SAFE',
+      DEX_SAFE_RUNTIME: 'java',
+    });
+    return;
   }
 }
 
@@ -167,12 +334,46 @@ function getComposerHome() {
   return path.join(home, '.dex', 'composer');
 }
 
-function isAndroidStoragePath(projectRoot) {
-  return projectRoot.startsWith('/sdcard') || projectRoot.startsWith('/storage/emulated/0');
+async function hasJavaBuildFiles(pomPath, gradlePath, gradleKtsPath) {
+  return Boolean(await pathExists(pomPath) || await pathExists(gradlePath) || await pathExists(gradleKtsPath));
+}
+
+async function ensureSafeWorkspaceMatchesProject(safeProjectDir, projectRoot, projectType) {
+  const metadataPath = path.join(safeProjectDir, '.dex-workspace.json');
+  let metadataRaw = '';
+
+  try {
+    metadataRaw = await fs.readFile(metadataPath, 'utf8');
+  } catch {
+    return;
+  }
+
+  try {
+    const metadata = JSON.parse(metadataRaw);
+    if (metadata.projectRoot && metadata.projectRoot !== projectRoot) {
+      throw new Error('workspace-root-mismatch');
+    }
+    if (metadata.projectType && metadata.projectType !== projectType) {
+      throw new Error('workspace-type-mismatch');
+    }
+  } catch (error) {
+    if (error && (error.message === 'workspace-root-mismatch' || error.message === 'workspace-type-mismatch')) {
+      throw error;
+    }
+  }
+}
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
 }
 
 function supportsSafeMode(projectType) {
-  return projectType === 'python' || projectType === 'node' || projectType === 'php';
+  return projectType === 'python' || projectType === 'node' || projectType === 'php' || projectType === 'ruby' || projectType === 'go' || projectType === 'rust' || projectType === 'java';
 }
 
 function openSafeShell(interactiveShell, cwd, envPatch) {

package/src/commands/search.js

@@ -1,8 +1,10 @@
 import fs from 'node:fs/promises';
+import { loadUserConfig } from '../core/config.js';
 import { chooseSearchScope } from '../ui/prompt.js';
 import { formatSearchResults, printSection } from '../ui/output.js';
 import { getScopeOptions, resolveScopeRoot } from '../core/scopes.js';
 import { searchEntries } from '../utils/fs-search.js';
+import { resolvePlatformMode } from '../utils/platform.js';
 
 export async function runSearchCommand({ pattern, scope }) {
   const cleanPattern = (pattern || '').trim();
@@ -11,7 +13,9 @@ export async function runSearchCommand({ pattern, scope }) {
     throw new Error('Debes indicar un patron. Ejemplo: dex -b "archivo"');
   }
 
-  const scopeOptions = getScopeOptions();
+  const config = await loadUserConfig();
+  const platformMode = resolvePlatformMode(config);
+  const scopeOptions = getScopeOptions(platformMode);
   const selectedScope = scope || await chooseSearchScope(scopeOptions);
   const root = resolveScopeRoot(selectedScope, scopeOptions);
 

package/src/commands/tree.js

@@ -1,12 +1,16 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { loadUserConfig } from '../core/config.js';
 import { chooseSearchScope } from '../ui/prompt.js';
 import { formatTreeReport, printSection } from '../ui/output.js';
 import { getScopeOptions, resolveScopeRoot } from '../core/scopes.js';
 import { buildTreeReport } from '../utils/fs-tree.js';
+import { resolvePlatformMode } from '../utils/platform.js';
 
 export async function runTreeCommand({ target, scope, depth }) {
-  const scopeOptions = getScopeOptions();
+  const config = await loadUserConfig();
+  const platformMode = resolvePlatformMode(config);
+  const scopeOptions = getScopeOptions(platformMode);
   const selectedScope = scope || await chooseSearchScope(scopeOptions);
   const root = resolveScopeRoot(selectedScope, scopeOptions);
 

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

@@ -32,12 +32,22 @@ export function parseArgs(argv) {
       continue;
     }
 
+    if (token === '--prompt-project-root') {
+      parsed.command = 'prompt-project-root';
+      continue;
+    }
+
+    if (token === '--prompt-project-path') {
+      parsed.command = 'prompt-project-path';
+      continue;
+    }
+
     if (token === '-m' || token === '--menu' || token === 'menu') {
       parsed.command = 'menu';
       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('-')) {
@@ -47,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('-')) {
@@ -77,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

@@ -1,21 +1,24 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { getHomeDirectory, normalizePlatformMode } from '../utils/platform.js';
 
 const DEFAULT_CONFIG = {
   features: {
-    androidShortcut: false,
-    projectBadge: false,
+    androidShortcut: true,
+    projectBadge: true,
     smartProjectInstall: false,
   },
   ui: {
     promptContextPosition: 'right',
   },
+  runtime: {
+    platformMode: 'auto',
+  },
   projects: {},
 };
 
 export function getUserConfigPath() {
-  const home = process.env.HOME || '/data/data/com.termux/files/home';
-  return path.join(home, '.config', 'dex', 'config.json');
+  return path.join(getHomeDirectory(), '.config', 'dex', 'config.json');
 }
 
 export async function loadUserConfig() {
@@ -71,6 +74,34 @@ export async function setPromptContextPosition(position) {
   return saveUserConfig(nextConfig);
 }
 
+export async function setPlatformMode(platformMode) {
+  const config = await loadUserConfig();
+  const normalized = normalizePlatformMode(platformMode);
+  const nextFeatures = {
+    ...config.features,
+  };
+
+  if (normalized === 'linux') {
+    nextFeatures.androidShortcut = true;
+    nextFeatures.projectBadge = true;
+    nextFeatures.smartProjectInstall = true;
+  }
+
+  if (normalized === 'termux') {
+    nextFeatures.androidShortcut = true;
+    nextFeatures.projectBadge = true;
+  }
+
+  return saveUserConfig({
+    ...config,
+    features: nextFeatures,
+    runtime: {
+      ...config.runtime,
+      platformMode: normalized,
+    },
+  });
+}
+
 export async function saveProjectState(projectKey, projectState) {
   const config = await loadUserConfig();
   const nextConfig = {
@@ -124,6 +155,11 @@ function mergeConfig(config) {
       ...(config.ui || {}),
       promptContextPosition: normalizePromptContextPosition(config.ui?.promptContextPosition),
     },
+    runtime: {
+      ...DEFAULT_CONFIG.runtime,
+      ...(config.runtime || {}),
+      platformMode: normalizePlatformMode(config.runtime?.platformMode),
+    },
     projects: {
       ...DEFAULT_CONFIG.projects,
       ...(config.projects || {}),
@@ -139,6 +175,9 @@ function cloneDefaultConfig() {
     ui: {
       ...DEFAULT_CONFIG.ui,
     },
+    runtime: {
+      ...DEFAULT_CONFIG.runtime,
+    },
     projects: {
       ...DEFAULT_CONFIG.projects,
     },

package/src/core/scopes.js

@@ -1,9 +1,14 @@
 import path from 'node:path';
+import {
+  canUseAndroidFeatures,
+  getAndroidStorageRoot,
+  getHomeDirectory,
+  getHomeScopeDescription,
+  getHomeScopeLabel,
+} from '../utils/platform.js';
 
-export function getScopeOptions() {
-  const home = process.env.HOME || '/data/data/com.termux/files/home';
-
-  return [
+export function getScopeOptions(platformMode) {
+  const options = [
     {
       key: 'actual',
       label: 'Carpeta actual',
@@ -12,20 +17,25 @@ export function getScopeOptions() {
     },
     {
       key: 'home',
-      label: 'Home de Termux',
-      root: home,
-      description: 'Busca dentro de tu entorno principal de Termux.',
+      label: getHomeScopeLabel(platformMode),
+      root: getHomeDirectory(),
+      description: getHomeScopeDescription(platformMode),
     },
-    {
+  ];
+
+  if (canUseAndroidFeatures(platformMode)) {
+    options.push({
       key: 'android',
       label: 'Almacenamiento Android',
-      root: '/sdcard',
+      root: getAndroidStorageRoot(platformMode),
       description: 'Busca dentro del almacenamiento compartido accesible.',
-    },
-  ];
+    });
+  }
+
+  return options;
 }
 
-export function resolveScopeRoot(scopeKey, options = getScopeOptions()) {
+export function resolveScopeRoot(scopeKey, options = []) {
   const found = options.find((option) => option.key === scopeKey);
   return found ? path.resolve(found.root) : '';
 }

package/src/ui/output.js

@@ -12,7 +12,8 @@ const ANSI = {
 export function printHelp() {
   printBanner();
   console.log('');
-  console.log('  Explorar, entender y preparar proyectos desde Termux y Android storage.');
+  console.log('  Explorar, entender y preparar proyectos desde Termux o Linux.');
+  console.log('  Android storage aparece cuando el modo de plataforma lo permite.');
   console.log('');
 
   printBlock('Comandos principales', [
@@ -22,22 +23,24 @@ export function printHelp() {
     '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',
+    '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 o Linux',
   ]);
 
   printBlock('Uso rapido', [
     'dex -b "*.js" --scope actual',
-    'dex -t . --depth 3',
+    'dex -t . --depth 3 --scope actual',
     'dex -c',
     'dex --prompt-context',
+    'dex --prompt-project-root',
+    'dex --prompt-project-path',
   ]);
 
   printBlock('Scopes', [
     'actual              carpeta donde estas parado',
-    'home                tu HOME de Termux',
-    'android             almacenamiento accesible',
+    'home                tu HOME del entorno actual',
+    'android             almacenamiento accesible en modo Termux',
   ]);
 
   printBlock('Atajos', [