dex-termux-cli 0.1.0

package/src/ui/output.js

@@ -0,0 +1,129 @@
+import path from 'node:path';
+import { getUserConfigPath } from '../core/config.js';
+
+export function printHelp() {
+  console.log('Dex CLI');
+  console.log('');
+  console.log('Acciones principales:');
+  console.log('  dex -h                ver ayuda');
+  console.log('  dex -m                abrir menu');
+  console.log('  dex -e ls             explicar un comando');
+  console.log('  dex -b "archivo"      buscar por nombre');
+  console.log('  dex -t src            ver arbol guiado');
+  console.log('  dex -a                abrir Android directo');
+  console.log('  dex -i                instalar dependencias del proyecto');
+  console.log('  dex -r                abrir shell del modo seguro');
+  console.log('');
+  console.log('Busqueda:');
+  console.log('  dex -b "foto"');
+  console.log('  dex -b "*.js" --scope actual');
+  console.log('  Dex -b "whatsapp" --scope android');
+  console.log('');
+  console.log('Arbol:');
+  console.log('  dex -t');
+  console.log('  dex -t src --scope actual');
+  console.log('  dex -t . --depth 3');
+  console.log('');
+  console.log('Android:');
+  console.log('  dex -a');
+  console.log('  activar en: ' + getUserConfigPath());
+  console.log('');
+  console.log('Instalacion segura de proyectos:');
+  console.log('  dex -i');
+  console.log('  detecta el lenguaje del proyecto actual');
+  console.log('  intenta instalar dependencias segun el lenguaje');
+  console.log('  si falta el runtime intenta traerlo con pkg');
+  console.log('  en Android storage ya existe modo seguro para Python, Node y PHP');
+  console.log('');
+  console.log('Modo seguro:');
+  console.log('  dex -r');
+  console.log('  abre una shell del entorno seguro del proyecto actual');
+  console.log('  en Python usa el venv seguro; en Node y PHP abre la copia segura en HOME');
+  console.log('');
+  console.log('Extras visuales:');
+  console.log('  detector de proyecto por carpeta actual');
+  console.log('  badge de lenguaje con color');
+  console.log('  activar en Ajustes y funciones');
+  console.log('');
+  console.log('Scopes:');
+  console.log('  actual    carpeta donde estas parado');
+  console.log('  home      tu entorno de Termux');
+  console.log('  android   /sdcard y almacenamiento accesible');
+  console.log('');
+  console.log('Atajos:');
+  console.log('  -h, --help');
+  console.log('  -m, --menu');
+  console.log('  -e, --explicar');
+  console.log('  -b, --buscar');
+  console.log('  -t, --tree');
+  console.log('  -a, --android');
+  console.log('  -i, --instalar');
+  console.log('  -r, --seguro');
+  console.log('  -s, --scope');
+  console.log('  -d, --depth');
+  console.log('');
+  console.log('Nota: si no pasas --scope en busqueda o tree, Dex te pregunta antes.');
+}
+
+export function printSection(title) {
+  console.log('== ' + title + ' ==');
+}
+
+export function printProjectContextLine(line) {
+  console.log(line);
+  console.log('');
+}
+
+export function formatSearchResults(results, root) {
+  if (!results.length) {
+    return 'No se encontraron coincidencias.';
+  }
+
+  return results
+    .map((item, index) => {
+      const relative = path.relative(root, item.path) || '.';
+      const suffix = item.type === 'directory' ? '/' : '';
+      return (index + 1) + '. ' + relative + suffix;
+    })
+    .join('\n');
+}
+
+export function printExplainEntry(topic, entry) {
+  const notes = entry.notes.map((note, index) => (index + 1) + '. ' + note).join('\n');
+
+  return [
+    'Comando : ' + topic,
+    'Que hace: ' + entry.summary,
+    'Riesgo  : ' + entry.risk,
+    '',
+    'Uso base:',
+    entry.usage,
+    '',
+    'Notas:',
+    notes,
+  ].join('\n');
+}
+
+export function formatTreeReport(report) {
+  const lines = [];
+
+  lines.push('Punto  : ' + report.label);
+  lines.push('Ruta   : ' + report.root);
+  lines.push('Prof.  : ' + report.depth);
+  lines.push('Modo   : vista guiada de carpetas y archivos');
+  lines.push('');
+  lines.push('Mapa:');
+  lines.push(...report.lines);
+  lines.push('');
+  lines.push('Resumen: ' + report.directories + ' carpetas, ' + report.files + ' archivos visibles.');
+
+  if (report.truncatedByDepth) {
+    lines.push('Nota   : hay mas niveles abajo. Prueba con --depth ' + (report.depth + 1) + '.');
+  }
+
+  if (report.truncatedByLimit) {
+    lines.push('Nota   : la vista fue recortada para que no se vuelva ruido.');
+  }
+
+  return lines.join('\n');
+}

package/src/ui/prompt.js

@@ -0,0 +1,299 @@
+import readline from 'node:readline/promises';
+import { moveCursor, cursorTo } from 'node:readline';
+import { stdin as input, stdout as output } from 'node:process';
+
+const ANSI = {
+  clearDown: '\x1B[0J',
+  green: '\x1B[32m',
+  red: '\x1B[31m',
+  reset: '\x1B[0m',
+};
+
+export async function chooseSearchScope(options) {
+  return chooseNumericOption({
+    title: 'Elige donde quieres buscar:',
+    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.',
+    directMatch: (answer) => options.find((option) => option.key === answer.toLowerCase())?.key,
+  });
+}
+
+export async function chooseExplainTopic(entries) {
+  const topics = Object.keys(entries).map((topic) => ({ topic }));
+
+  return chooseNumericOption({
+    title: 'Elige un comando para explicar:',
+    options: topics,
+    getValue: (option) => option.topic,
+    getLines: (option) => [option.topic],
+    prompt: 'Tema [1-' + topics.length + ', nombre, Enter=1]: ',
+    errorMessage: 'Opcion no valida. Usa un numero o el nombre del comando.',
+    directMatch: (answer) => topics.find((option) => option.topic === answer.toLowerCase())?.topic,
+  });
+}
+
+export async function chooseMenuAction() {
+  const options = [
+    { key: 'search', label: 'Buscar archivos o carpetas' },
+    { key: 'explain', label: 'Explicar un comando' },
+    { key: 'tree', label: 'Ver arbol de una ruta' },
+    { key: 'safe-shell', label: 'Entrar al modo seguro del proyecto' },
+    { key: 'settings', label: 'Ajustes y funciones' },
+    { key: 'help', label: 'Ver ayuda' },
+    { key: 'exit', label: 'Salir' },
+  ];
+
+  return chooseNumericOption({
+    title: 'Dex Menu',
+    options,
+    getValue: (option) => option.key,
+    getLines: (option) => [option.label],
+    prompt: 'Opcion [1-' + options.length + ', Enter=1]: ',
+    errorMessage: 'Opcion no valida. Usa un numero entre 1 y 7.',
+    directMatch: (answer) => options.find((option) => option.key === answer.toLowerCase())?.key,
+  });
+}
+
+export async function chooseSettingsAction(config) {
+  const options = [
+    {
+      key: 'toggle-android-shortcut',
+      label: 'Acceso rapido a Android',
+      status: formatStatus(config.features.androidShortcut),
+      usage: 'permite dex -a',
+    },
+    {
+      key: 'toggle-project-badge',
+      label: 'Detector de proyecto y color',
+      status: formatStatus(config.features.projectBadge),
+      usage: 'muestra lenguaje y color del proyecto',
+    },
+    {
+      key: 'toggle-smart-project-install',
+      label: 'Instalacion segura de proyectos',
+      status: formatStatus(config.features.smartProjectInstall),
+      usage: 'rescata instalaciones y puede instalar runtimes con pkg',
+    },
+    {
+      key: 'back',
+      label: 'Volver al menu principal',
+    },
+  ];
+
+  return chooseNumericOption({
+    title: 'Ajustes de Dex',
+    options,
+    getValue: (option) => option.key,
+    getLines: (option) => {
+      if (option.key === 'back') {
+        return [option.label];
+      }
+
+      return [
+        option.label,
+        'Estado : ' + option.status,
+        'Uso    : ' + option.usage,
+      ];
+    },
+    prompt: 'Ajuste [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',
+  });
+}
+
+export async function chooseFeatureToggle(currentValue, featureName, description) {
+  const options = [
+    {
+      key: 'enable',
+      label: 'Activar',
+      usage: description,
+    },
+    {
+      key: 'disable',
+      label: 'Desactivar',
+      usage: 'oculta ' + featureName.toLowerCase() + ' hasta volver a activarlo',
+    },
+    {
+      key: 'back',
+      label: 'Volver',
+    },
+  ];
+
+  return chooseNumericOption({
+    title: featureName,
+    options,
+    getValue: (option) => option.key,
+    getLines: (option) => {
+      if (option.key === 'back') {
+        return [option.label];
+      }
+
+      return [
+        option.label,
+        'Uso    : ' + option.usage,
+      ];
+    },
+    prompt: 'Accion [1-' + options.length + ', Enter=3]: ',
+    errorMessage: 'Opcion no valida. Usa 1, 2 o 3.',
+    directMatch: (answer) => options.find((option) => option.key === answer.toLowerCase())?.key,
+    defaultIndex: 2,
+    style: 'card',
+    introLines: ['Estado actual: ' + formatStatus(currentValue)],
+  });
+}
+
+export async function chooseSearchPatternFromMenu() {
+  const rl = readline.createInterface({ input, output });
+
+  try {
+    while (true) {
+      const answer = (await rl.question('Patron a buscar: ')).trim();
+
+      if (answer) {
+        return answer;
+      }
+
+      console.log('Debes escribir algo para buscar.');
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+export async function chooseTreeTargetFromMenu() {
+  const rl = readline.createInterface({ input, output });
+
+  try {
+    const answer = (await rl.question('Ruta a mostrar [Enter=.]: ')).trim();
+    return answer || '.';
+  } finally {
+    rl.close();
+  }
+}
+
+async function chooseNumericOption({
+  title,
+  options,
+  getValue,
+  getLines,
+  prompt,
+  errorMessage,
+  directMatch,
+  defaultIndex = 0,
+  style = 'simple',
+  introLines = [],
+}) {
+  const rl = readline.createInterface({ input, output });
+  const blockLineCount = countRenderedLines(options, getLines, introLines, style) + 5;
+
+  try {
+    printOptionBlock(title, options, getLines, style, introLines);
+
+    while (true) {
+      const answer = (await rl.question(prompt)).trim();
+      const selectedValue = resolveAnswer(answer, options, getValue, directMatch, defaultIndex);
+
+      if (selectedValue) {
+        clearOptionBlock(blockLineCount);
+        return selectedValue;
+      }
+
+      console.log(errorMessage);
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+function printOptionBlock(title, options, getLines, style, introLines) {
+  console.log(title);
+  console.log('');
+
+  for (const line of introLines) {
+    console.log(line);
+  }
+
+  if (introLines.length) {
+    console.log('');
+  }
+
+  options.forEach((option, index) => {
+    const lines = getLines(option);
+
+    if (style === 'card') {
+      console.log('[' + (index + 1) + '] ' + lines[0]);
+
+      for (let lineIndex = 1; lineIndex < lines.length; lineIndex += 1) {
+        console.log('    - ' + lines[lineIndex]);
+      }
+
+      console.log('');
+      return;
+    }
+
+    console.log((index + 1) + '. ' + lines[0]);
+
+    for (let lineIndex = 1; lineIndex < lines.length; lineIndex += 1) {
+      console.log('   - ' + lines[lineIndex]);
+    }
+  });
+
+  console.log('Tip: puedes escribir el numero o el nombre corto cuando aplique.');
+  console.log('');
+}
+
+function countRenderedLines(options, getLines, introLines, style) {
+  let count = 2 + introLines.length;
+
+  if (introLines.length) {
+    count += 1;
+  }
+
+  for (const option of options) {
+    count += getLines(option).length;
+
+    if (style === 'card') {
+      count += 1;
+    }
+  }
+
+  return count;
+}
+
+function resolveAnswer(answer, options, getValue, directMatch, defaultIndex) {
+  if (!answer) {
+    return getValue(options[defaultIndex]);
+  }
+
+  const numeric = Number.parseInt(answer, 10);
+  if (Number.isInteger(numeric) && numeric >= 1 && numeric <= options.length) {
+    return getValue(options[numeric - 1]);
+  }
+
+  return directMatch(answer) || '';
+}
+
+function clearOptionBlock(lineCount) {
+  if (!input.isTTY || !output.isTTY) {
+    return;
+  }
+
+  moveCursor(output, 0, -lineCount);
+  cursorTo(output, 0);
+  output.write(ANSI.clearDown);
+}
+
+function formatStatus(enabled) {
+  const text = enabled ? 'activado' : 'desactivado';
+
+  if (!output.isTTY) {
+    return text;
+  }
+
+  const color = enabled ? ANSI.green : ANSI.red;
+  return color + text + ANSI.reset;
+}

package/src/utils/fs-search.js

@@ -0,0 +1,63 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+export async function searchEntries({ root, pattern, limit = 80 }) {
+  const results = [];
+  const matcher = createMatcher(pattern);
+
+  async function walk(currentPath) {
+    if (results.length >= limit) {
+      return;
+    }
+
+    let entries;
+    try {
+      entries = await fs.readdir(currentPath, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (results.length >= limit) {
+        return;
+      }
+
+      const fullPath = path.join(currentPath, entry.name);
+      const relativePath = path.relative(root, fullPath);
+
+      if (matcher(entry.name) || matcher(relativePath)) {
+        results.push({
+          path: fullPath,
+          type: entry.isDirectory() ? 'directory' : 'file',
+        });
+      }
+
+      if (entry.isDirectory() && !shouldSkipDirectory(entry.name)) {
+        await walk(fullPath);
+      }
+    }
+  }
+
+  await walk(root);
+  return results;
+}
+
+function createMatcher(pattern) {
+  const clean = pattern.trim().toLowerCase();
+
+  if (clean.includes('*')) {
+    const source = escapeRegex(clean).replaceAll('\\*', '.*');
+    const regex = new RegExp(`^${source}$`, 'i');
+    return (value) => regex.test(value.toLowerCase());
+  }
+
+  return (value) => value.toLowerCase().includes(clean);
+}
+
+function escapeRegex(value) {
+  return value.replace(/[|\\{}()[\]^$+?.*]/g, '\\$&');
+}
+
+function shouldSkipDirectory(name) {
+  return name === '.git' || name === 'node_modules';
+}

package/src/utils/fs-tree.js

@@ -0,0 +1,131 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const COLORS = {
+  reset: '\x1b[0m',
+  folder: '\x1b[36m',
+  hint: '\x1b[90m',
+};
+
+export async function buildTreeReport({ root, label, depth = 2, limit = 120 }) {
+  const lines = [formatDirectoryLabel(`${path.basename(root) || root}/`)];
+  const counters = {
+    directories: 0,
+    files: 0,
+    visibleNodes: 0,
+    truncatedByDepth: false,
+    truncatedByLimit: false,
+  };
+
+  await walk(root, '', 1);
+
+  return {
+    label,
+    root,
+    depth,
+    lines,
+    directories: counters.directories,
+    files: counters.files,
+    truncatedByDepth: counters.truncatedByDepth,
+    truncatedByLimit: counters.truncatedByLimit,
+  };
+
+  async function walk(currentPath, prefix, currentDepth) {
+    if (counters.visibleNodes >= limit) {
+      counters.truncatedByLimit = true;
+      return;
+    }
+
+    let entries;
+    try {
+      entries = await fs.readdir(currentPath, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    const visibleEntries = entries
+      .filter((entry) => !shouldSkipDirectory(entry.name))
+      .sort(sortEntries);
+
+    for (let index = 0; index < visibleEntries.length; index += 1) {
+      if (counters.visibleNodes >= limit) {
+        counters.truncatedByLimit = true;
+        return;
+      }
+
+      const entry = visibleEntries[index];
+      const isLast = index === visibleEntries.length - 1;
+      const branch = isLast ? '└── ' : '├── ';
+      const childPrefix = `${prefix}${isLast ? '    ' : '│   '}`;
+      const fullPath = path.join(currentPath, entry.name);
+      const label = entry.isDirectory()
+        ? formatDirectoryLabel(`${entry.name}/`)
+        : entry.name;
+
+      lines.push(`${prefix}${branch}${label}`);
+      counters.visibleNodes += 1;
+
+      if (entry.isDirectory()) {
+        counters.directories += 1;
+      } else {
+        counters.files += 1;
+      }
+
+      if (!entry.isDirectory()) {
+        continue;
+      }
+
+      if (currentDepth >= depth) {
+        if (await hasVisibleChildren(fullPath)) {
+          counters.truncatedByDepth = true;
+          lines.push(`${childPrefix}${formatHint('└── ... mas dentro')}`);
+          counters.visibleNodes += 1;
+        }
+        continue;
+      }
+
+      await walk(fullPath, childPrefix, currentDepth + 1);
+    }
+  }
+}
+
+function formatDirectoryLabel(value) {
+  if (!process.stdout.isTTY) {
+    return value;
+  }
+
+  return `${COLORS.folder}${value}${COLORS.reset}`;
+}
+
+function formatHint(value) {
+  if (!process.stdout.isTTY) {
+    return value;
+  }
+
+  return `${COLORS.hint}${value}${COLORS.reset}`;
+}
+
+async function hasVisibleChildren(directoryPath) {
+  try {
+    const entries = await fs.readdir(directoryPath, { withFileTypes: true });
+    return entries.some((entry) => !shouldSkipDirectory(entry.name));
+  } catch {
+    return false;
+  }
+}
+
+function sortEntries(left, right) {
+  if (left.isDirectory() && !right.isDirectory()) {
+    return -1;
+  }
+
+  if (!left.isDirectory() && right.isDirectory()) {
+    return 1;
+  }
+
+  return left.name.localeCompare(right.name, 'es', { sensitivity: 'base' });
+}
+
+function shouldSkipDirectory(name) {
+  return name === '.git' || name === 'node_modules';
+}

package/src/utils/project-context.js

@@ -0,0 +1,82 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const COLORS = {
+  reset: '\x1b[0m',
+  python: '\x1b[34m',
+  node: '\x1b[31m',
+  rust: '\x1b[33m',
+  go: '\x1b[36m',
+  java: '\x1b[35m',
+  php: '\x1b[95m',
+  ruby: '\x1b[91m',
+  generic: '\x1b[92m',
+};
+
+export async function detectProjectContext(cwd = process.cwd()) {
+  const entries = await safeReadDir(cwd);
+  if (!entries.length) {
+    return null;
+  }
+
+  const names = new Set(entries.map((entry) => entry.name));
+  const hasPyFiles = entries.some((entry) => !entry.isDirectory() && entry.name.endsWith('.py'));
+  const hasJsFiles = entries.some((entry) => !entry.isDirectory() && isNodeScript(entry.name));
+  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, 'PYTHON');
+  }
+
+  if (names.has('package.json') || names.has('node_modules') || hasJsFiles) {
+    return createContext('node', cwd, 'NODE');
+  }
+
+  if (names.has('Cargo.toml')) {
+    return createContext('rust', cwd, 'RUST');
+  }
+
+  if (names.has('go.mod')) {
+    return createContext('go', cwd, 'GO');
+  }
+
+  if (names.has('pom.xml') || names.has('build.gradle') || names.has('build.gradle.kts')) {
+    return createContext('java', cwd, 'JAVA');
+  }
+
+  if (names.has('composer.json') || hasPhpFiles) {
+    return createContext('php', cwd, 'PHP');
+  }
+
+  if (names.has('Gemfile') || hasRubyFiles) {
+    return createContext('ruby', cwd, 'RUBY');
+  }
+
+  return null;
+}
+
+export function formatProjectContext(context) {
+  const folderName = path.basename(context.cwd) || context.cwd;
+  const badge = process.stdout.isTTY
+    ? `${COLORS[context.type] || COLORS.generic}[${context.label}]${COLORS.reset}`
+    : `[${context.label}]`;
+
+  return `Contexto: ${folderName} ${badge}`;
+}
+
+function createContext(type, cwd, label) {
+  return { type, cwd, label };
+}
+
+async function safeReadDir(directoryPath) {
+  try {
+    return await fs.readdir(directoryPath, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+
+function isNodeScript(name) {
+  return name.endsWith('.js') || name.endsWith('.mjs') || name.endsWith('.cjs') || name.endsWith('.ts');
+}