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

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.2",
   "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/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

@@ -101,8 +101,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 +111,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/ui/output.js

@@ -25,7 +25,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,7 +33,8 @@ 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', [

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

@@ -56,6 +56,57 @@ 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';
 }

package/src/utils/project-context.js

@@ -63,7 +63,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,9 +136,45 @@ async function detectProjectContextAt(targetDir, cwd) {
     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;
 }
 
+async function detectImplicitLanguageFromChildren(targetDir, entries) {
+  const childDirectories = entries
+    .filter((entry) => entry.isDirectory())
+    .slice(0, 8);
+
+  for (const entry of childDirectories) {
+    const nestedEntries = await safeReadDir(path.join(targetDir, entry.name));
+    if (!nestedEntries.length) {
+      continue;
+    }
+
+    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 '';
+}
+
 function pickBestDetection(detections) {
   let bestMatch = detections[0];
 
@@ -279,6 +315,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 });