dex-termux-cli 0.1.0

package/src/commands/menu.js

@@ -0,0 +1,120 @@
+import { loadUserConfig, setFeatureEnabled } from '../core/config.js';
+import { runExplainCommand } from './explain.js';
+import { runSafeShellCommand } from './safe-shell.js';
+import { runSearchCommand } from './search.js';
+import { runTreeCommand } from './tree.js';
+import {
+  chooseFeatureToggle,
+  chooseMenuAction,
+  chooseSearchPatternFromMenu,
+  chooseSettingsAction,
+  chooseTreeTargetFromMenu,
+} from '../ui/prompt.js';
+import { printHelp } from '../ui/output.js';
+
+export async function runMenuCommand() {
+  while (true) {
+    const action = await chooseMenuAction();
+
+    if (action === 'help') {
+      printHelp();
+      return;
+    }
+
+    if (action === 'search') {
+      const pattern = await chooseSearchPatternFromMenu();
+      await runSearchCommand({ pattern, scope: '' });
+      return;
+    }
+
+    if (action === 'explain') {
+      await runExplainCommand({ topic: '' });
+      return;
+    }
+
+    if (action === 'tree') {
+      const target = await chooseTreeTargetFromMenu();
+      await runTreeCommand({ target, scope: '', depth: 2 });
+      return;
+    }
+
+    if (action === 'safe-shell') {
+      await runSafeShellCommand();
+      return;
+    }
+
+    if (action === 'settings') {
+      await runSettingsMenu();
+      continue;
+    }
+
+    if (action === 'exit') {
+      console.log('Saliendo de Dex.');
+      return;
+    }
+  }
+}
+
+async function runSettingsMenu() {
+  while (true) {
+    const config = await loadUserConfig();
+    const action = await chooseSettingsAction(config);
+
+    if (action === 'back') {
+      return;
+    }
+
+    if (action === 'toggle-android-shortcut') {
+      const toggle = await chooseFeatureToggle(
+        config.features.androidShortcut,
+        'Acceso rapido a Android',
+        'permite usar dex -a o dex --android',
+      );
+
+      if (toggle === 'back') {
+        continue;
+      }
+
+      const enabled = toggle === 'enable';
+      await setFeatureEnabled('androidShortcut', enabled);
+      console.log(`Acceso rapido a Android: ${enabled ? 'activado' : 'desactivado'}.`);
+      console.log('');
+      continue;
+    }
+
+    if (action === 'toggle-project-badge') {
+      const toggle = await chooseFeatureToggle(
+        config.features.projectBadge,
+        'Detector de proyecto y color',
+        'muestra el tipo de proyecto actual con color segun lenguaje',
+      );
+
+      if (toggle === 'back') {
+        continue;
+      }
+
+      const enabled = toggle === 'enable';
+      await setFeatureEnabled('projectBadge', enabled);
+      console.log(`Detector de proyecto y color: ${enabled ? 'activado' : 'desactivado'}.`);
+      console.log('');
+      continue;
+    }
+
+    if (action === 'toggle-smart-project-install') {
+      const toggle = await chooseFeatureToggle(
+        config.features.smartProjectInstall,
+        'Instalacion segura de proyectos',
+        'instala dependencias y si falta el runtime intenta traerlo con pkg',
+      );
+
+      if (toggle === 'back') {
+        continue;
+      }
+
+      const enabled = toggle === 'enable';
+      await setFeatureEnabled('smartProjectInstall', enabled);
+      console.log(`Instalacion segura de proyectos: ${enabled ? 'activado' : 'desactivado'}.`);
+      console.log('');
+    }
+  }
+}

package/src/commands/safe-shell.js

@@ -0,0 +1,200 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { loadUserConfig } from '../core/config.js';
+import { detectProjectContext } from '../utils/project-context.js';
+
+export async function runSafeShellCommand() {
+  const config = await loadUserConfig();
+
+  if (!config.features.smartProjectInstall) {
+    throw new Error('La instalacion segura de proyectos esta desactivada. Activa esa funcion antes de abrir el modo seguro.');
+  }
+
+  const projectRoot = process.cwd();
+  const projectContext = await detectProjectContext();
+
+  if (!projectContext || !supportsSafeMode(projectContext.type)) {
+    throw new Error('El modo seguro de Dex por ahora solo existe para proyectos Python, Node y PHP.');
+  }
+
+  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 projectKey = getProjectKey(projectRoot);
+  const projectState = config.projects && config.projects[projectKey] ? config.projects[projectKey] : null;
+  const shell = process.env.SHELL || '/data/data/com.termux/files/usr/bin/sh';
+  const reason = projectState && projectState.preferSafeInstall
+    ? 'Este proyecto ya quedo marcado para modo seguro.'
+    : 'Entrando al entorno seguro manual de Dex.';
+
+  if (projectContext.type === 'python') {
+    const venvDir = getRescueVenvPath(projectRoot);
+    const rescuePython = path.join(venvDir, 'bin', 'python');
+
+    try {
+      await fs.access(rescuePython);
+    } catch {
+      throw new Error('No encontre el entorno seguro de este proyecto. Corre dex -i primero para prepararlo.');
+    }
+
+    const venvBin = path.join(venvDir, 'bin');
+    const nextPath = venvBin + ':' + (process.env.PATH || '');
+
+    console.log('Modo Dex : shell segura para ' + path.basename(projectRoot));
+    console.log('Proyecto : ' + projectRoot);
+    console.log('Entorno  : ' + venvDir);
+    console.log('Python   : ' + rescuePython);
+    console.log('Nota     : ' + reason);
+    console.log('Usa python, pip o python bot.py desde aqui.');
+    console.log('Si sales de esta shell, el modo seguro deja de estar activo.');
+    console.log('Escribe exit para volver a tu shell normal.');
+    console.log('');
+
+    await openSafeShell(shell, projectRoot, {
+      PATH: nextPath,
+      VIRTUAL_ENV: venvDir,
+      DEX_CONTEXT: 'safe-shell',
+      DEX_SAFE_PROJECT: projectRoot,
+      DEX_SAFE_PROJECT_KEY: projectKey,
+    });
+    return;
+  }
+
+  if (projectContext.type === 'node') {
+    const safeProjectDir = getSafeProjectWorkspacePath(projectRoot, projectContext.type);
+    const packageJsonPath = path.join(safeProjectDir, 'package.json');
+    const nodeModulesDir = path.join(safeProjectDir, 'node_modules');
+    const nodeBinDir = path.join(nodeModulesDir, '.bin');
+
+    try {
+      await fs.access(packageJsonPath);
+      await fs.access(nodeModulesDir);
+    } catch {
+      throw new Error('No encontre el espacio seguro de este proyecto Node. Corre dex -i primero para prepararlo.');
+    }
+
+    const nextPath = nodeBinDir + ':' + (process.env.PATH || '');
+
+    console.log('Modo Dex : shell segura para ' + path.basename(projectRoot));
+    console.log('Proyecto : ' + projectRoot);
+    console.log('Seguro   : ' + safeProjectDir);
+    console.log('Modulos  : ' + nodeModulesDir);
+    console.log('Nota     : ' + reason);
+    console.log('Usa node, npm o npm 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(shell, safeProjectDir, {
+      PATH: nextPath,
+      DEX_CONTEXT: 'safe-shell',
+      DEX_SAFE_PROJECT: projectRoot,
+      DEX_SAFE_PROJECT_KEY: projectKey,
+      DEX_SAFE_WORKSPACE: safeProjectDir,
+    });
+    return;
+  }
+
+  if (projectContext.type === 'php') {
+    const safeProjectDir = getSafeProjectWorkspacePath(projectRoot, projectContext.type);
+    const composerJsonPath = path.join(safeProjectDir, 'composer.json');
+    const vendorDir = path.join(safeProjectDir, 'vendor');
+    const vendorBinDir = path.join(vendorDir, 'bin');
+    const composerHome = getComposerHome();
+
+    try {
+      await fs.access(composerJsonPath);
+      await fs.access(vendorDir);
+    } catch {
+      throw new Error('No encontre el espacio seguro de este proyecto PHP. Corre dex -i primero para prepararlo.');
+    }
+
+    const nextPath = vendorBinDir + ':' + (process.env.PATH || '');
+
+    console.log('Modo Dex : shell segura para ' + path.basename(projectRoot));
+    console.log('Proyecto : ' + projectRoot);
+    console.log('Seguro   : ' + safeProjectDir);
+    console.log('Vendor   : ' + vendorDir);
+    console.log('Nota     : ' + reason);
+    console.log('Usa php, composer o binarios de vendor/bin 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 fs.mkdir(composerHome, { recursive: true });
+
+    await openSafeShell(shell, safeProjectDir, {
+      PATH: nextPath,
+      COMPOSER_HOME: composerHome,
+      DEX_CONTEXT: 'safe-shell',
+      DEX_SAFE_PROJECT: projectRoot,
+      DEX_SAFE_PROJECT_KEY: projectKey,
+      DEX_SAFE_WORKSPACE: safeProjectDir,
+    });
+  }
+}
+
+function getProjectKey(projectRoot) {
+  return createHash('sha1').update(projectRoot).digest('hex');
+}
+
+function getRescueVenvPath(projectRoot) {
+  const home = process.env.HOME || '/data/data/com.termux/files/home';
+  const digest = createHash('sha1').update(projectRoot).digest('hex').slice(0, 8);
+  const baseName = path.basename(projectRoot).toLowerCase().replace(/[^a-z0-9._-]+/g, '-');
+  const safeName = baseName || 'project';
+  return path.join(home, '.dex', 'venvs', safeName + '-' + digest);
+}
+
+function getSafeProjectWorkspacePath(projectRoot, projectType) {
+  const home = process.env.HOME || '/data/data/com.termux/files/home';
+  const digest = createHash('sha1').update(projectRoot).digest('hex').slice(0, 8);
+  const baseName = path.basename(projectRoot).toLowerCase().replace(/[^a-z0-9._-]+/g, '-');
+  const safeName = baseName || projectType || 'project';
+  const safeKind = projectType || 'project';
+  return path.join(home, '.dex', 'projects', safeKind, safeName + '-' + digest);
+}
+
+function getComposerHome() {
+  const home = process.env.HOME || '/data/data/com.termux/files/home';
+  return path.join(home, '.dex', 'composer');
+}
+
+function isAndroidStoragePath(projectRoot) {
+  return projectRoot.startsWith('/sdcard') || projectRoot.startsWith('/storage/emulated/0');
+}
+
+function supportsSafeMode(projectType) {
+  return projectType === 'python' || projectType === 'node' || projectType === 'php';
+}
+
+function openSafeShell(shell, cwd, envPatch) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(shell, ['-i'], {
+      cwd,
+      stdio: 'inherit',
+      env: {
+        ...process.env,
+        ...envPatch,
+      },
+    });
+
+    child.on('error', reject);
+    child.on('exit', (code, signal) => {
+      if (signal) {
+        reject(new Error('La shell segura termino por senal: ' + signal));
+        return;
+      }
+
+      if (code && code !== 0) {
+        reject(new Error('La shell segura termino con codigo ' + code));
+        return;
+      }
+
+      resolve();
+    });
+  });
+}

package/src/commands/search.js

@@ -0,0 +1,41 @@
+import fs from 'node:fs/promises';
+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';
+
+export async function runSearchCommand({ pattern, scope }) {
+  const cleanPattern = (pattern || '').trim();
+
+  if (!cleanPattern) {
+    throw new Error('Debes indicar un patron. Ejemplo: dex -b "archivo"');
+  }
+
+  const scopeOptions = getScopeOptions();
+  const selectedScope = scope || await chooseSearchScope(scopeOptions);
+  const root = resolveScopeRoot(selectedScope, scopeOptions);
+
+  if (!root) {
+    throw new Error(`Alcance no valido: ${selectedScope}`);
+  }
+
+  try {
+    await fs.access(root);
+  } catch {
+    throw new Error(`No se puede acceder a la ruta: ${root}`);
+  }
+
+  printSection('Busqueda');
+  console.log(`Patron : ${cleanPattern}`);
+  console.log(`Alcance: ${selectedScope}`);
+  console.log(`Ruta   : ${root}`);
+  console.log('');
+
+  const results = await searchEntries({
+    root,
+    pattern: cleanPattern,
+    limit: 80,
+  });
+
+  console.log(formatSearchResults(results, root));
+}

package/src/commands/tree.js

@@ -0,0 +1,61 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+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';
+
+export async function runTreeCommand({ target, scope, depth }) {
+  const scopeOptions = getScopeOptions();
+  const selectedScope = scope || await chooseSearchScope(scopeOptions);
+  const root = resolveScopeRoot(selectedScope, scopeOptions);
+
+  if (!root) {
+    throw new Error(`Alcance no valido: ${selectedScope}`);
+  }
+
+  const cleanTarget = (target || '.').trim() || '.';
+  const resolvedTarget = path.resolve(root, cleanTarget);
+  const relativeToRoot = path.relative(root, resolvedTarget);
+
+  if (relativeToRoot.startsWith('..') || path.isAbsolute(relativeToRoot)) {
+    throw new Error('La ruta pedida se sale del scope elegido.');
+  }
+
+  let stats;
+  try {
+    await fs.access(resolvedTarget);
+    stats = await fs.stat(resolvedTarget);
+  } catch {
+    throw new Error(`No se puede acceder a la ruta: ${resolvedTarget}`);
+  }
+
+  printSection('Tree');
+  console.log(`Scope  : ${selectedScope}`);
+  console.log(`Base   : ${root}`);
+  console.log(`Objetivo: ${cleanTarget}`);
+  console.log('');
+
+  if (!stats.isDirectory()) {
+    console.log(formatTreeReport({
+      label: cleanTarget,
+      root: resolvedTarget,
+      depth,
+      directories: 0,
+      files: 1,
+      truncatedByDepth: false,
+      truncatedByLimit: false,
+      lines: [path.basename(resolvedTarget)],
+    }));
+    return;
+  }
+
+  const report = await buildTreeReport({
+    root: resolvedTarget,
+    label: cleanTarget,
+    depth,
+    limit: 120,
+  });
+
+  console.log(formatTreeReport(report));
+}

package/src/core/args.js

@@ -0,0 +1,114 @@
+export function parseArgs(argv) {
+  const parsed = {
+    help: false,
+    command: '',
+    pattern: '',
+    topic: '',
+    target: '',
+    scope: '',
+    depth: 2,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+
+    if (token === '-h' || token === '--help' || token === 'help') {
+      parsed.help = true;
+      continue;
+    }
+
+    if (token === '-m' || token === '--menu' || token === 'menu') {
+      parsed.command = 'menu';
+      continue;
+    }
+
+    if (token === '-b' || token === '--buscar') {
+      parsed.command = 'search';
+      const next = argv[index + 1];
+      if (next && !next.startsWith('-')) {
+        parsed.pattern = next;
+        index += 1;
+      }
+      continue;
+    }
+
+    if (token === '-e' || token === '--explicar' || token === 'explicar') {
+      parsed.command = 'explain';
+      const next = argv[index + 1];
+      if (next && !next.startsWith('-')) {
+        parsed.topic = next;
+        index += 1;
+      }
+      continue;
+    }
+
+    if (token === '-t' || token === '--tree' || token === 'tree') {
+      parsed.command = 'tree';
+      const next = argv[index + 1];
+      if (next && !next.startsWith('-')) {
+        parsed.target = next;
+        index += 1;
+      }
+      continue;
+    }
+
+    if (token === '-a' || token === '--android' || token === 'android') {
+      parsed.command = 'android';
+      continue;
+    }
+
+    if (token === '-i' || token === '--instalar' || token === '--install' || token === 'install') {
+      parsed.command = 'install';
+      continue;
+    }
+
+    if (token === '-r' || token === '--seguro' || token === '--safe-shell' || token === 'seguro') {
+      parsed.command = 'safe-shell';
+      continue;
+    }
+
+    if (token === '-s' || token === '--scope') {
+      const next = argv[index + 1];
+      if (next) {
+        parsed.scope = next.toLowerCase();
+        index += 1;
+      }
+      continue;
+    }
+
+    if (token === '-d' || token === '--depth') {
+      const next = argv[index + 1];
+      if (next) {
+        parsed.depth = normalizeDepth(next);
+        index += 1;
+      }
+      continue;
+    }
+
+    if (!parsed.pattern && parsed.command === 'search') {
+      parsed.pattern = token;
+      continue;
+    }
+
+    if (!parsed.topic && parsed.command === 'explain') {
+      parsed.topic = token;
+      continue;
+    }
+
+    if (!parsed.target && parsed.command === 'tree') {
+      parsed.target = token;
+    }
+  }
+
+  return parsed;
+}
+
+function normalizeDepth(value) {
+  const numeric = Number.parseInt(value, 10);
+
+  if (!Number.isInteger(numeric) || numeric < 1) {
+    return 2;
+  }
+
+  return numeric;
+}

package/src/core/config.js

@@ -0,0 +1,122 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const DEFAULT_CONFIG = {
+  features: {
+    androidShortcut: false,
+    projectBadge: false,
+    smartProjectInstall: false,
+  },
+  projects: {},
+};
+
+export function getUserConfigPath() {
+  const home = process.env.HOME || '/data/data/com.termux/files/home';
+  return path.join(home, '.config', 'dex', 'config.json');
+}
+
+export async function loadUserConfig() {
+  const configPath = getUserConfigPath();
+
+  try {
+    const raw = await fs.readFile(configPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return mergeConfig(parsed);
+  } catch (error) {
+    if (error && error.code !== 'ENOENT') {
+      throw new Error(`No pude leer la configuracion de Dex: ${error.message}`);
+    }
+
+    await ensureUserConfigExists(configPath);
+    return cloneDefaultConfig();
+  }
+}
+
+export async function saveUserConfig(config) {
+  const configPath = getUserConfigPath();
+  const merged = mergeConfig(config);
+
+  await fs.mkdir(path.dirname(configPath), { recursive: true });
+  await fs.writeFile(configPath, `${JSON.stringify(merged, null, 2)}\n`, 'utf8');
+
+  return merged;
+}
+
+export async function setFeatureEnabled(featureKey, enabled) {
+  const config = await loadUserConfig();
+  const nextConfig = {
+    ...config,
+    features: {
+      ...config.features,
+      [featureKey]: enabled,
+    },
+  };
+
+  return saveUserConfig(nextConfig);
+}
+
+export async function saveProjectState(projectKey, projectState) {
+  const config = await loadUserConfig();
+  const nextConfig = {
+    ...config,
+    projects: {
+      ...(config.projects || {}),
+      [projectKey]: {
+        ...((config.projects || {})[projectKey] || {}),
+        ...projectState,
+      },
+    },
+  };
+
+  return saveUserConfig(nextConfig);
+}
+
+export async function clearProjectState(projectKey) {
+  const config = await loadUserConfig();
+  const nextProjects = { ...(config.projects || {}) };
+  delete nextProjects[projectKey];
+
+  return saveUserConfig({
+    ...config,
+    projects: nextProjects,
+  });
+}
+
+async function ensureUserConfigExists(configPath) {
+  await fs.mkdir(path.dirname(configPath), { recursive: true });
+  await fs.writeFile(configPath, `${JSON.stringify(DEFAULT_CONFIG, null, 2)}\n`, { flag: 'wx' }).catch((error) => {
+    if (!error || error.code !== 'EEXIST') {
+      throw error;
+    }
+  });
+}
+
+function mergeConfig(config) {
+  const features = {
+    ...DEFAULT_CONFIG.features,
+    ...(config.features || {}),
+  };
+
+  if (typeof config?.features?.smartPythonInstall === 'boolean' && typeof config?.features?.smartProjectInstall !== 'boolean') {
+    features.smartProjectInstall = config.features.smartPythonInstall;
+  }
+
+  return {
+    features,
+    projects: {
+      ...DEFAULT_CONFIG.projects,
+      ...(config.projects || {}),
+    },
+  };
+}
+
+function cloneDefaultConfig() {
+  return {
+    features: {
+      ...DEFAULT_CONFIG.features,
+    },
+    projects: {
+      ...DEFAULT_CONFIG.projects,
+    },
+  };
+}

package/src/core/scopes.js

@@ -0,0 +1,31 @@
+import path from 'node:path';
+
+export function getScopeOptions() {
+  const home = process.env.HOME || '/data/data/com.termux/files/home';
+
+  return [
+    {
+      key: 'actual',
+      label: 'Carpeta actual',
+      root: process.cwd(),
+      description: 'Busca solo dentro de donde estas parado ahora.',
+    },
+    {
+      key: 'home',
+      label: 'Home de Termux',
+      root: home,
+      description: 'Busca dentro de tu entorno principal de Termux.',
+    },
+    {
+      key: 'android',
+      label: 'Almacenamiento Android',
+      root: '/sdcard',
+      description: 'Busca dentro del almacenamiento compartido accesible.',
+    },
+  ];
+}
+
+export function resolveScopeRoot(scopeKey, options = getScopeOptions()) {
+  const found = options.find((option) => option.key === scopeKey);
+  return found ? path.resolve(found.root) : '';
+}