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

package/src/ui/prompt.js

@@ -3,14 +3,14 @@ import { moveCursor, cursorTo } from 'node:readline';
 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',
+  clearDown: '',
+  cyan: '',
+  dim: '',
+  green: '',
+  red: '',
+  reset: '',
+  yellow: '',
+  bold: '',
 };
 
 export async function chooseSearchScope(options) {
@@ -20,7 +20,7 @@ export async function chooseSearchScope(options) {
     getValue: (option) => option.key,
     getLines: (option) => [option.label, option.description, option.root],
     prompt: 'Scope [1-' + options.length + ', Enter=1]: ',
-    errorMessage: 'Opcion no valida. Usa un numero o actual/home/android.',
+    errorMessage: 'Opcion no valida. Usa un numero o una clave valida.',
     directMatch: (answer) => options.find((option) => option.key === answer.toLowerCase())?.key,
   });
 }
@@ -47,7 +47,7 @@ export async function chooseMenuAction() {
     { 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: 'settings', label: 'Ajustes y funciones', hint: 'activa extras, plataforma y prompt' },
     { key: 'help', label: 'Ver ayuda', hint: 'muestra comandos y ejemplos' },
     { key: 'exit', label: 'Salir', hint: 'cerrar el menu' },
   ];
@@ -67,11 +67,17 @@ export async function chooseMenuAction() {
 
 export async function chooseSettingsAction(config) {
   const options = [
+    {
+      key: 'platform-mode',
+      label: 'Modo de plataforma',
+      status: formatPlatformMode(config.runtime?.platformMode || 'auto'),
+      usage: 'elige auto, termux o linux',
+    },
     {
       key: 'toggle-android-shortcut',
-      label: 'Acceso rapido a Android',
+      label: 'Acceso rapido',
       status: formatStatus(config.features.androidShortcut),
-      usage: 'permite dex -a',
+      usage: 'permite dex -a en Termux o Linux',
     },
     {
       key: 'toggle-project-badge',
@@ -89,7 +95,7 @@ export async function chooseSettingsAction(config) {
       key: 'toggle-smart-project-install',
       label: 'Instalacion segura de proyectos',
       status: formatStatus(config.features.smartProjectInstall),
-      usage: 'rescata instalaciones y puede instalar runtimes con pkg',
+      usage: 'rescata instalaciones y usa modo seguro por lenguaje',
     },
     {
       key: 'back',
@@ -113,7 +119,7 @@ export async function chooseSettingsAction(config) {
       ];
     },
     prompt: 'Ajuste [1-' + options.length + ', Enter=1]: ',
-    errorMessage: 'Opcion no valida. Usa 1, 2, 3, 4 o 5.',
+    errorMessage: 'Opcion no valida. Usa 1, 2, 3, 4, 5 o 6.',
     directMatch: (answer) => options.find((option) => option.key === answer.toLowerCase())?.key,
     style: 'card',
     introLines: ['Activa solo lo que quieras ver todos los dias.'],
@@ -165,6 +171,51 @@ export async function choosePromptContextPosition(currentPosition) {
   });
 }
 
+export async function choosePlatformMode(currentMode) {
+  const options = [
+    {
+      key: 'auto',
+      label: 'Auto',
+      usage: 'detecta si estas en Termux o Linux segun el entorno real',
+    },
+    {
+      key: 'termux',
+      label: 'Modo Termux',
+      usage: 'activa comportamiento centrado en Android storage y Termux',
+    },
+    {
+      key: 'linux',
+      label: 'Modo Linux',
+      usage: 'desactiva Android y asume un entorno Linux puro',
+    },
+    {
+      key: 'back',
+      label: 'Volver',
+    },
+  ];
+
+  return chooseNumericOption({
+    title: 'Modo de plataforma',
+    options,
+    getValue: (option) => option.key,
+    getLines: (option) => {
+      if (option.key === 'back') {
+        return [option.label];
+      }
+
+      return [
+        option.label,
+        'Uso    : ' + option.usage,
+      ];
+    },
+    prompt: 'Modo [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: ' + formatPlatformMode(currentMode)],
+  });
+}
+
 export async function chooseFeatureToggle(currentValue, featureName, description) {
   const options = [
     {
@@ -371,6 +422,18 @@ function formatPromptPosition(position) {
   return 'derecha';
 }
 
+function formatPlatformMode(mode) {
+  if (mode === 'linux') {
+    return 'linux';
+  }
+
+  if (mode === 'termux') {
+    return 'termux';
+  }
+
+  return 'auto';
+}
+
 function colorize(text, color, weight = '') {
   if (!output.isTTY) {
     return text;

package/src/utils/platform.js

@@ -0,0 +1,116 @@
+import path from 'node:path';
+
+const TERMUX_HOME = '/data/data/com.termux/files/home';
+const ANDROID_STORAGE = '/sdcard';
+
+export function getHomeDirectory() {
+  return process.env.HOME || TERMUX_HOME;
+}
+
+export function isHostTermux() {
+  const home = getHomeDirectory();
+  return Boolean(process.env.TERMUX_VERSION) || home === TERMUX_HOME || home.startsWith(TERMUX_HOME + path.sep);
+}
+
+export function normalizePlatformMode(mode) {
+  return ['auto', 'termux', 'linux'].includes(mode) ? mode : 'auto';
+}
+
+export function resolvePlatformMode(config) {
+  const configured = normalizePlatformMode(config?.runtime?.platformMode || 'auto');
+
+  if (configured !== 'auto') {
+    return configured;
+  }
+
+  return isHostTermux() ? 'termux' : 'linux';
+}
+
+export function formatPlatformMode(mode) {
+  if (mode === 'linux') {
+    return 'linux';
+  }
+
+  if (mode === 'termux') {
+    return 'termux';
+  }
+
+  return 'auto';
+}
+
+export function getHomeScopeLabel(platformMode) {
+  return platformMode === 'linux' ? 'Home de Linux' : 'Home de Termux';
+}
+
+export function getHomeScopeDescription(platformMode) {
+  return platformMode === 'linux'
+    ? 'Busca dentro de tu entorno principal de Linux.'
+    : 'Busca dentro de tu entorno principal de Termux.';
+}
+
+export function canUseAndroidFeatures(platformMode) {
+  return platformMode === 'termux';
+}
+
+export function getAndroidStorageRoot(platformMode) {
+  return canUseAndroidFeatures(platformMode) ? ANDROID_STORAGE : '';
+}
+
+export function getQuickAccessRoot(platformMode) {
+  return platformMode === 'termux' ? ANDROID_STORAGE : 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) {
+  return platformMode === 'termux' ? 'ANDROID STORAGE' : 'LINUX HOME';
+}
+
+export function getQuickAccessShortcutSummary(platformMode) {
+  return platformMode === 'termux'
+    ? 'dl, docs, dcim, pics, music, movies, shared'
+    : 'home, dl, docs, desk, pics, music, vids, tmp, shared';
+}
+
+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();
+  return {
+    home,
+    shared: home,
+    dl: path.join(home, 'Downloads'),
+    docs: path.join(home, 'Documents'),
+    desk: path.join(home, 'Desktop'),
+    pics: path.join(home, 'Pictures'),
+    music: path.join(home, 'Music'),
+    vids: path.join(home, 'Videos'),
+    tmp: '/tmp',
+  };
+}
+
+export function shouldRestrictProjectToAndroidStorage(platformMode) {
+  return platformMode === 'termux';
+}
+
+export function isAndroidStoragePath(targetPath) {
+  return targetPath.startsWith('/sdcard') || targetPath.startsWith('/storage/emulated/0');
+}

package/src/utils/project-context.js

@@ -23,8 +23,65 @@ const LANGUAGE_META = {
   ruby: { label: 'RUBY' },
 };
 
+const MAX_PARENT_LOOKUP = 16;
+
 export async function detectProjectContext(cwd = process.cwd()) {
-  const entries = await safeReadDir(cwd);
+  const searchChain = buildSearchChain(cwd);
+  const detections = [];
+
+  for (const directoryPath of searchChain) {
+    const detected = await detectProjectContextAt(directoryPath, cwd);
+    if (detected) {
+      detections.push(detected);
+    }
+  }
+
+  if (!detections.length) {
+    return null;
+  }
+
+  const explicit = detections.filter((item) => item.detectionKind === 'explicit');
+  if (explicit.length) {
+    return pickBestDetection(explicit);
+  }
+
+  return pickBestDetection(detections);
+}
+
+export function formatProjectContext(context) {
+  const folderName = path.basename(context.projectRoot || context.cwd) || context.cwd;
+  const segment = buildContextSegment(context);
+  const badge = process.stdout.isTTY
+    ? `${COLORS[context.type] || COLORS.generic}[${segment}]${COLORS.reset}`
+    : `[${segment}]`;
+
+  return `Contexto: ${folderName} ${badge}`;
+}
+
+export function formatPromptContext(context) {
+  return buildContextSegment(context);
+}
+
+export function formatPromptProjectRoot(context) {
+  return context.projectRoot || context.cwd;
+}
+
+export function formatPromptProjectPath(context) {
+  return context.projectRoot || context.cwd;
+}
+
+export function formatProjectContextDetails(context) {
+  return [
+    'Carpeta : ' + context.cwd,
+    'Proyecto: ' + (context.projectRoot || context.cwd),
+    'Tipo    : ' + context.label,
+    'Version : ' + (context.version || 'sin detectar'),
+    'Prompt  : [' + formatPromptContext(context) + ']',
+  ].join('\n');
+}
+
+async function detectProjectContextAt(targetDir, cwd) {
+  const entries = await safeReadDir(targetDir);
   if (!entries.length) {
     return null;
   }
@@ -35,67 +92,114 @@ export async function detectProjectContext(cwd = process.cwd()) {
   const hasPhpFiles = entries.some((entry) => !entry.isDirectory() && entry.name.endsWith('.php'));
   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, await detectPythonVersion(cwd));
+  if (names.has('pyproject.toml') || names.has('requirements.txt') || names.has('Pipfile') || names.has('setup.py')) {
+    return createContext('python', cwd, targetDir, await detectPythonVersion(targetDir), 'explicit');
   }
 
-  if (names.has('package.json') || names.has('node_modules') || hasJsFiles) {
-    return createContext('node', cwd, await detectNodeVersion(cwd));
+  if (names.has('package.json') || names.has('node_modules')) {
+    return createContext('node', cwd, targetDir, await detectNodeVersion(targetDir), 'explicit');
   }
 
   if (names.has('Cargo.toml')) {
-    return createContext('rust', cwd, await detectRustVersion(cwd));
+    return createContext('rust', cwd, targetDir, await detectRustVersion(targetDir), 'explicit');
   }
 
   if (names.has('go.mod')) {
-    return createContext('go', cwd, await detectGoVersion(cwd));
+    return createContext('go', cwd, targetDir, await detectGoVersion(targetDir), 'explicit');
   }
 
   if (names.has('pom.xml') || names.has('build.gradle') || names.has('build.gradle.kts')) {
-    return createContext('java', cwd, await detectJavaVersion(cwd));
+    return createContext('java', cwd, targetDir, await detectJavaVersion(targetDir), 'explicit');
+  }
+
+  if (names.has('composer.json')) {
+    return createContext('php', cwd, targetDir, await detectPhpVersion(targetDir), 'explicit');
+  }
+
+  if (names.has('Gemfile')) {
+    return createContext('ruby', cwd, targetDir, await detectRubyVersion(targetDir), 'explicit');
+  }
+
+  if (hasPyFiles) {
+    return createContext('python', cwd, targetDir, await detectPythonVersion(targetDir), 'implicit');
+  }
+
+  if (hasJsFiles) {
+    return createContext('node', cwd, targetDir, await detectNodeVersion(targetDir), 'implicit');
   }
 
-  if (names.has('composer.json') || hasPhpFiles) {
-    return createContext('php', cwd, await detectPhpVersion(cwd));
+  if (hasPhpFiles) {
+    return createContext('php', cwd, targetDir, await detectPhpVersion(targetDir), 'implicit');
   }
 
-  if (names.has('Gemfile') || hasRubyFiles) {
-    return createContext('ruby', cwd, await detectRubyVersion(cwd));
+  if (hasRubyFiles) {
+    return createContext('ruby', cwd, targetDir, await detectRubyVersion(targetDir), 'implicit');
+  }
+
+  const nestedImplicitType = await detectImplicitLanguageFromChildren(targetDir, entries);
+  if (nestedImplicitType) {
+    return createContext(nestedImplicitType, cwd, targetDir, await detectVersionForType(nestedImplicitType, targetDir), 'implicit');
   }
 
   return null;
 }
 
-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}[${segment}]${COLORS.reset}`
-    : `[${segment}]`;
+async function detectImplicitLanguageFromChildren(targetDir, entries) {
+  const childDirectories = entries
+    .filter((entry) => entry.isDirectory())
+    .slice(0, 8);
 
-  return `Contexto: ${folderName} ${badge}`;
-}
+  for (const entry of childDirectories) {
+    const nestedEntries = await safeReadDir(path.join(targetDir, entry.name));
+    if (!nestedEntries.length) {
+      continue;
+    }
 
-export function formatPromptContext(context) {
-  return buildContextSegment(context);
+    if (nestedEntries.some((item) => !item.isDirectory() && item.name.endsWith('.py'))) {
+      return 'python';
+    }
+
+    if (nestedEntries.some((item) => !item.isDirectory() && isNodeScript(item.name))) {
+      return 'node';
+    }
+
+    if (nestedEntries.some((item) => !item.isDirectory() && item.name.endsWith('.php'))) {
+      return 'php';
+    }
+
+    if (nestedEntries.some((item) => !item.isDirectory() && item.name.endsWith('.rb'))) {
+      return 'ruby';
+    }
+  }
+
+  return '';
 }
 
-export function formatProjectContextDetails(context) {
-  return [
-    'Carpeta : ' + context.cwd,
-    'Tipo    : ' + context.label,
-    'Version : ' + (context.version || 'sin detectar'),
-    'Prompt  : [' + formatPromptContext(context) + ']',
-  ].join('\n');
+function pickBestDetection(detections) {
+  let bestMatch = detections[0];
+
+  for (let index = 1; index < detections.length; index += 1) {
+    const current = detections[index];
+
+    if (current.type !== bestMatch.type) {
+      break;
+    }
+
+    bestMatch = current;
+  }
+
+  return bestMatch;
 }
 
-function createContext(type, cwd, version) {
+function createContext(type, cwd, projectRoot, version, detectionKind) {
   const meta = LANGUAGE_META[type] || { label: type.toUpperCase() };
   return {
     type,
     cwd,
+    projectRoot,
     label: meta.label,
     version,
+    detectionKind,
   };
 }
 
@@ -103,6 +207,22 @@ function buildContextSegment(context) {
   return context.label;
 }
 
+function buildSearchChain(cwd) {
+  const chain = [];
+  let current = path.resolve(cwd);
+
+  for (let depth = 0; depth < MAX_PARENT_LOOKUP; depth += 1) {
+    chain.push(current);
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+
+  return chain;
+}
+
 async function detectPythonVersion(cwd) {
   const pythonVersionFile = await readFileIfExists(path.join(cwd, '.python-version'));
   const pipfile = await readFileIfExists(path.join(cwd, 'Pipfile'));
@@ -190,11 +310,43 @@ async function detectJavaVersion(cwd) {
   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(gradle, /sourceCompatibility\s*=\s*['\"]?([^\s'\"]+)/i) ||
     matchVersion(gradleKts, /JavaLanguageVersion\.of\((\d+)\)/i),
   );
 }
 
+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 });

package/src/utils/shell.js

@@ -1,13 +1,17 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { isHostTermux } from './platform.js';
 
 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';
+const LINUX_ZSH = '/bin/zsh';
+const LINUX_BASH = '/bin/bash';
+const LINUX_SH = '/bin/sh';
 
-export async function resolveInteractiveShell() {
+export async function resolveInteractiveShell(platformMode = '') {
   const preferredShell = process.env.DEX_PREFERRED_SHELL || process.env.SHELL || '';
-  const candidates = buildShellCandidates(preferredShell);
+  const candidates = buildShellCandidates(preferredShell, platformMode);
 
   for (const shellPath of candidates) {
     if (!shellPath) {
@@ -24,20 +28,42 @@ export async function resolveInteractiveShell() {
   }
 
   return {
-    shellPath: TERMUX_SH,
+    shellPath: LINUX_SH,
     shellArgs: ['-i'],
     shellName: 'sh',
   };
 }
 
-function buildShellCandidates(preferredShell) {
+function buildShellCandidates(preferredShell, platformMode = '') {
   const shellName = path.basename(preferredShell || '');
+  const preferredFirst = preferredShell && shellName && shellName !== 'sh'
+    ? [preferredShell]
+    : [];
+  const preferTermuxShells = platformMode ? platformMode !== 'linux' : isHostTermux();
 
-  if (preferredShell && shellName && shellName !== 'sh') {
-    return dedupe([preferredShell, TERMUX_ZSH, TERMUX_BASH, TERMUX_SH]);
+  if (preferTermuxShells) {
+    return dedupe([
+      ...preferredFirst,
+      TERMUX_ZSH,
+      TERMUX_BASH,
+      LINUX_ZSH,
+      LINUX_BASH,
+      preferredShell,
+      TERMUX_SH,
+      LINUX_SH,
+    ]);
   }
 
-  return dedupe([TERMUX_ZSH, TERMUX_BASH, preferredShell, TERMUX_SH]);
+  return dedupe([
+    ...preferredFirst,
+    LINUX_ZSH,
+    LINUX_BASH,
+    preferredShell,
+    LINUX_SH,
+    TERMUX_ZSH,
+    TERMUX_BASH,
+    TERMUX_SH,
+  ]);
 }
 
 async function shellExists(shellPath) {