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

package/src/utils/platform.js

@@ -0,0 +1,65 @@
+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 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 path.basename(context.projectRoot || context.cwd) || 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,78 @@ 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');
   }
 
   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}]`;
+function pickBestDetection(detections) {
+  let bestMatch = detections[0];
 
-  return `Contexto: ${folderName} ${badge}`;
-}
+  for (let index = 1; index < detections.length; index += 1) {
+    const current = detections[index];
 
-export function formatPromptContext(context) {
-  return buildContextSegment(context);
-}
+    if (current.type !== bestMatch.type) {
+      break;
+    }
 
-export function formatProjectContextDetails(context) {
-  return [
-    'Carpeta : ' + context.cwd,
-    'Tipo    : ' + context.label,
-    'Version : ' + (context.version || 'sin detectar'),
-    'Prompt  : [' + formatPromptContext(context) + ']',
-  ].join('\n');
+    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 +171,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,7 +274,7 @@ 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),
   );
 }

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) {