dotdotdot-cli 1.0.0

package/lib/context.js

@@ -0,0 +1,265 @@
+'use strict';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// context.js — Rich environment context gathering for LLM prompts
+// ─────────────────────────────────────────────────────────────────────────────
+
+const os   = require('os');
+const path = require('path');
+const fs   = require('fs');
+const { execSync, exec } = require('child_process');
+const { promisify }      = require('util');
+const { CACHE_DIR }      = require('./config');
+
+const execAsync = promisify(exec);
+const CACHE_FILE = path.join(CACHE_DIR, 'context-cache.json');
+const CACHE_TTL  = 3600000; // 1 hour
+
+// ─── Safe exec wrappers ─────────────────────────────────────────────────────
+
+function safeExec(cmd, fallback = '') {
+  try {
+    const suppress = process.platform === 'win32' ? ' 2>nul' : ' 2>/dev/null';
+    return execSync(cmd + suppress, { timeout: 2000, encoding: 'utf8' }).trim();
+  } catch {
+    return fallback;
+  }
+}
+
+async function safeExecAsync(cmd, fallback = '') {
+  try {
+    const suppress = process.platform === 'win32' ? ' 2>nul' : ' 2>/dev/null';
+    const { stdout } = await execAsync(cmd + suppress, { timeout: 2000 });
+    return stdout.trim();
+  } catch {
+    return fallback;
+  }
+}
+
+// ─── Cache management ───────────────────────────────────────────────────────
+
+function loadCache() {
+  try {
+    const raw = fs.readFileSync(CACHE_FILE, 'utf8');
+    const data = JSON.parse(raw);
+    if (Date.now() - data._ts < CACHE_TTL) return data;
+  } catch { /* miss */ }
+  return null;
+}
+
+function saveCache(data) {
+  try {
+    fs.writeFileSync(CACHE_FILE, JSON.stringify({ ...data, _ts: Date.now() }));
+  } catch { /* ignore */ }
+}
+
+// ─── Shell detection ────────────────────────────────────────────────────────
+
+function detectShell(cache) {
+  // NEVER use cached shell — user may switch between PowerShell, Git Bash, CMD.
+  // Shell detection is fast (<50ms), so always detect fresh.
+
+  const platform = process.platform;
+  let name, shellPath, version, isPowerShell = false, isCmd = false, isBash = false;
+
+  if (platform === 'win32') {
+    // Check for Git Bash / MINGW / MSYS FIRST.
+    // Key: $SHELL is set to a bash path (e.g. '/usr/bin/bash') only inside Git Bash.
+    // MSYSTEM alone is unreliable — it leaks into PowerShell on systems with Git installed.
+    const envShell = process.env.SHELL;  // '/usr/bin/bash' in Git Bash, undefined in PS
+    const isMingwBash = envShell && (envShell.includes('bash') || envShell.includes('/sh'));
+
+    if (isMingwBash) {
+      name = 'bash'; shellPath = envShell; isBash = true;
+      version = safeExec('bash --version');
+      if (version.length > 80) version = version.split('\n')[0].slice(0, 80);
+    } else {
+      // Check for PowerShell 7+ first
+      const pwshVer = safeExec('pwsh -NoProfile -Command "$PSVersionTable.PSVersion.ToString()"');
+      if (pwshVer) {
+        name = 'pwsh'; shellPath = 'pwsh'; version = pwshVer; isPowerShell = true;
+      } else {
+        const psVer = safeExec('powershell -NoProfile -Command "$PSVersionTable.PSVersion.ToString()"');
+        if (psVer) {
+          name = 'powershell'; shellPath = 'powershell'; version = psVer; isPowerShell = true;
+        } else {
+          name = 'cmd'; shellPath = process.env.ComSpec || 'cmd.exe'; isCmd = true;
+          version = safeExec('ver');
+        }
+      }
+    }
+  } else {
+    shellPath = process.env.SHELL || '/bin/sh';
+    name = path.basename(shellPath);
+    version = safeExec(`${shellPath} --version`);
+    if (version.length > 80) version = version.slice(0, 80);
+  }
+
+  return { name, path: shellPath, version, isPowerShell, isCmd, isBash, platform };
+}
+
+// ─── Directory listing ──────────────────────────────────────────────────────
+
+function getDirectoryListing(dir) {
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const items = [];
+    let count = 0;
+    const MAX = 30; // reduced from 50 — saves tokens
+
+    for (const entry of entries) {
+      if (count >= MAX) {
+        items.push(`+${entries.length - MAX} more`);
+        break;
+      }
+      // Skip hidden files except useful ones
+      if (entry.name.startsWith('.') && !['.env', '.gitignore', '.dockerignore', '.nvmrc'].includes(entry.name)) continue;
+      if (entry.name === 'node_modules') { items.push('node_modules/'); count++; continue; }
+
+      // Just name + trailing slash for dirs. No file sizes — saves tokens.
+      items.push(entry.isDirectory() ? entry.name + '/' : entry.name);
+      count++;
+    }
+    return items.join(',');
+  } catch {
+    return '';
+  }
+}
+
+// ─── Git info ───────────────────────────────────────────────────────────────
+
+async function getGitInfo() {
+  const branch = await safeExecAsync('git branch --show-current');
+  if (!branch) return null;
+  const status = await safeExecAsync('git status --short');
+  return {
+    branch,
+    isDirty: status.length > 0,
+    // Limit to 5 lines max — just enough for LLM context
+    status: status ? status.split('\n').slice(0, 5).join('\n') : '',
+  };
+}
+
+// ─── Installed tools ────────────────────────────────────────────────────────
+
+async function getInstalledTools(cache) {
+  if (cache?.tools) return cache.tools;
+
+  const checks = [
+    { name: 'node',   cmd: 'node --version' },
+    { name: 'npm',    cmd: 'npm --version' },
+    { name: 'python', cmd: process.platform === 'win32' ? 'python --version' : 'python3 --version' },
+    { name: 'git',    cmd: 'git --version' },
+    { name: 'docker', cmd: 'docker --version' },
+    { name: 'go',     cmd: 'go version' },
+    { name: 'cargo',  cmd: 'cargo --version' },
+    { name: 'pip',    cmd: process.platform === 'win32' ? 'pip --version' : 'pip3 --version' },
+  ];
+
+  const results = await Promise.all(
+    checks.map(async ({ name, cmd }) => {
+      const ver = await safeExecAsync(cmd);
+      // Just store the tool name — version detail wastes tokens, LLM just needs to know it's available
+      return ver ? { name } : null;
+    })
+  );
+
+  const tools = results.filter(Boolean);
+
+  // Detect package manager
+  const cwd = process.cwd();
+  if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml')))    tools.push({ name: 'pnpm', version: await safeExecAsync('pnpm --version') || 'installed' });
+  if (fs.existsSync(path.join(cwd, 'yarn.lock')))          tools.push({ name: 'yarn', version: await safeExecAsync('yarn --version') || 'installed' });
+  if (fs.existsSync(path.join(cwd, 'bun.lockb')))          tools.push({ name: 'bun',  version: await safeExecAsync('bun --version') || 'installed' });
+
+  return tools;
+}
+
+// ─── Project info ───────────────────────────────────────────────────────────
+
+function getProjectInfo() {
+  const cwd = process.cwd();
+  const info = { type: null, name: null, scripts: null, deps: null, files: [] };
+
+  // package.json
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+    info.type = 'node';
+    info.name = pkg.name;
+    info.scripts = pkg.scripts ? Object.keys(pkg.scripts).slice(0, 10) : [];
+    const deps = Object.keys(pkg.dependencies || {}).slice(0, 10);
+    const devDeps = Object.keys(pkg.devDependencies || {}).slice(0, 5);
+    info.deps = { deps, devDeps };
+  } catch { /* not a node project */ }
+
+  // Project indicator files
+  const indicators = [
+    'Cargo.toml', 'pyproject.toml', 'setup.py', 'go.mod',
+    'Makefile', 'CMakeLists.txt', 'Dockerfile', 'docker-compose.yml',
+    'docker-compose.yaml', 'tsconfig.json', '.eslintrc.json',
+    'vite.config.ts', 'vite.config.js', 'next.config.js', 'next.config.mjs',
+    'webpack.config.js', 'tailwind.config.js', 'tailwind.config.ts',
+    '.env', '.env.local', 'Procfile', 'vercel.json', 'netlify.toml',
+    'wrangler.toml', 'fly.toml',
+  ];
+
+  for (const f of indicators) {
+    if (fs.existsSync(path.join(cwd, f))) info.files.push(f);
+  }
+
+  return info;
+}
+
+// ─── Environment ────────────────────────────────────────────────────────────
+
+function getEnvironment() {
+  return {
+    virtualEnv:  process.env.VIRTUAL_ENV || process.env.CONDA_DEFAULT_ENV || null,
+    isSSH:       !!process.env.SSH_CLIENT || !!process.env.SSH_TTY,
+    isDocker:    fs.existsSync('/.dockerenv'),
+    isWSL:       process.platform === 'linux' && safeExec('uname -r').toLowerCase().includes('microsoft'),
+    user:        os.userInfo().username,
+  };
+}
+
+// ─── Main gather function ───────────────────────────────────────────────────
+
+async function gatherContext() {
+  const cache = loadCache();
+
+  const shell = detectShell(cache);
+  const [gitInfo, tools] = await Promise.all([
+    getGitInfo(),
+    getInstalledTools(cache),
+  ]);
+
+  const context = {
+    system: {
+      platform: process.platform,
+      osName: `${os.type()} ${os.release()}`,
+      arch: os.arch(),
+    },
+    shell,
+    cwd: process.cwd(),
+    dirListing: getDirectoryListing(process.cwd()),
+    gitInfo,
+    tools,
+    projectInfo: getProjectInfo(),
+    environment: getEnvironment(),
+  };
+
+  // Save to cache (tools only — shell must never be cached, user switches terminals)
+  if (!cache) {
+    saveCache({ tools });
+  }
+
+  return context;
+}
+
+module.exports = {
+  gatherContext,
+  detectShell,
+  getDirectoryListing,
+  safeExec,
+  safeExecAsync,
+};

package/lib/executor.js

@@ -0,0 +1,274 @@
+'use strict';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// executor.js — Command execution, clipboard, interactive menu
+// ─────────────────────────────────────────────────────────────────────────────
+
+const { spawn, execSync } = require('child_process');
+const { bold, dim, cyan, green, red, yellow, symbols } = require('./colors');
+const { addEntry, getUserIntent } = require('./session');
+const { commandBox, printError, printInfo, Spinner, subtle } = require('./renderer');
+const { selectMenu } = require('./menu');
+const { analyzeRisk } = require('./safety');
+const { tokenLine, estimateCost } = require('./tokens');
+
+// ─── Strip accidental shell wrappers from LLM output ────────────────────────
+// LLMs sometimes wrap commands in "powershell -Command ..." when already in PS,
+// or "bash -c ..." when already in bash. Only strip if it matches current shell.
+function stripShellWrapper(cmd) {
+  const { shell } = detectBestShell();
+  const shellName = shell.toLowerCase().replace(/\.exe$/, '');
+  const baseName = require('path').basename(shellName);
+
+  let c = cmd;
+
+  // Only strip PowerShell wrappers if we're running IN PowerShell
+  if (baseName === 'pwsh' || baseName === 'powershell') {
+    c = c.replace(/^powershell(?:\.exe)?\s+(?:-NoProfile\s+)?-Command\s+["']?/i, '').replace(/["']?\s*$/, '');
+    c = c.replace(/^pwsh(?:\.exe)?\s+(?:-NoProfile\s+)?-Command\s+["']?/i, '').replace(/["']?\s*$/, '');
+  }
+
+  // Only strip bash wrappers if we're running IN bash
+  if (baseName === 'bash' || baseName === 'sh' || baseName === 'zsh') {
+    c = c.replace(/^bash\s+-c\s+["']/i, '').replace(/["']\s*$/, '');
+    c = c.replace(/^sh\s+-c\s+["']/i, '').replace(/["']\s*$/, '');
+  }
+
+  // Only strip cmd wrappers if we're running IN cmd
+  if (baseName === 'cmd') {
+    c = c.replace(/^cmd(?:\.exe)?\s+\/c\s+["']?/i, '').replace(/["']?\s*$/, '');
+  }
+
+  return c;
+}
+
+// ─── Detect shell ───────────────────────────────────────────────────────────
+
+function detectBestShell(config) {
+  if (config?.preferredShell) return { shell: config.preferredShell, flag: '-c' };
+  if (process.platform !== 'win32') return { shell: process.env.SHELL || '/bin/sh', flag: '-c' };
+
+  // Git Bash / MINGW / MSYS — $SHELL is set to bash path only inside Git Bash
+  const envShell = process.env.SHELL;
+  if (envShell && (envShell.includes('bash') || envShell.includes('/sh'))) {
+    return { shell: envShell, flag: '-c' };
+  }
+
+  try { execSync('pwsh -NoProfile -Command "exit"', { timeout: 2000, stdio: 'ignore' }); return { shell: 'pwsh', flag: '-Command' }; } catch {}
+  try { execSync('powershell -NoProfile -Command "exit"', { timeout: 2000, stdio: 'ignore' }); return { shell: 'powershell', flag: '-Command' }; } catch {}
+  return { shell: process.env.ComSpec || 'cmd.exe', flag: '/c' };
+}
+
+// ─── Run command ────────────────────────────────────────────────────────────
+
+function runCommand(command, config, opts = {}) {
+  const { shell, flag } = detectBestShell(config);
+  const { silent = false, captureOnly = false, tokenUsage = null } = opts;
+
+  return new Promise((resolve) => {
+    if (!silent && !captureOnly) {
+      console.log();
+    }
+
+    // For PowerShell, use -EncodedCommand to avoid $() string terminator issues.
+    // Base64-encode the command as UTF-16LE (PowerShell's expected encoding).
+    let spawnArgs;
+    const shellBase = require('path').basename(shell).toLowerCase().replace(/\.exe$/, '');
+    if (shellBase === 'powershell' || shellBase === 'pwsh') {
+      const encoded = Buffer.from(command, 'utf16le').toString('base64');
+      spawnArgs = ['-NoProfile', '-EncodedCommand', encoded];
+    } else {
+      spawnArgs = [flag, command];
+    }
+
+    const proc = spawn(shell, spawnArgs, {
+      stdio: captureOnly ? ['pipe', 'pipe', 'pipe'] : ['inherit', 'pipe', 'pipe'],
+      env: { ...process.env },
+    });
+
+    let output = '';
+    let stderrIsClixml = false;
+    proc.stdout?.on('data', (d) => { const t = d.toString(); output += t; if (!silent && !captureOnly) process.stdout.write(t); });
+    proc.stderr?.on('data', (d) => {
+      const t = d.toString();
+      // Filter PowerShell CLIXML noise (progress bars, module loading messages).
+      // Once we see the CLIXML header, all subsequent stderr is CLIXML until process ends.
+      if (t.includes('#< CLIXML')) stderrIsClixml = true;
+      if (stderrIsClixml) return;
+      output += t;
+      if (!silent && !captureOnly) process.stderr.write(t);
+    });
+
+    proc.on('close', (code) => {
+      addEntry(command, output, code, getUserIntent());
+      if (!silent && !captureOnly) {
+        if (tokenUsage) {
+          const tl = tokenLine(tokenUsage);
+          const cost = estimateCost(tokenUsage, config.provider, config.model);
+          const costStr = cost ? dim(` ~$${cost}`) : '';
+          console.log(`\n  ${dim(tl)}${costStr}`);
+        }
+        const mark = code === 0 ? green(symbols.check) : red(symbols.cross);
+        console.log(`  ${mark} ${dim(`exit ${code}`)}`);
+      }
+      resolve({ code, output });
+    });
+
+    proc.on('error', (err) => {
+      addEntry(command, err.message, 1, getUserIntent());
+      if (!silent && !captureOnly) console.error(`  ${red(symbols.cross)} ${err.message}`);
+      resolve({ code: 1, output: err.message });
+    });
+  });
+}
+
+// ─── Clipboard ──────────────────────────────────────────────────────────────
+
+function copyToClipboard(text) {
+  try {
+    const p = process.platform;
+    if (p === 'win32') execSync('clip', { input: text, timeout: 3000 });
+    else if (p === 'darwin') execSync('pbcopy', { input: text, timeout: 3000 });
+    else { try { execSync('xclip -selection clipboard', { input: text, timeout: 3000 }); } catch { execSync('xsel --clipboard --input', { input: text, timeout: 3000 }); } }
+    return true;
+  } catch { return false; }
+}
+
+// ─── Interactive mode ───────────────────────────────────────────────────────
+
+async function interactiveMode(result, config, context) {
+  const { command: rawCommand, explanation, warning, _tokenUsage } = result;
+  const command = stripShellWrapper(rawCommand);
+  const risk = analyzeRisk(command);
+  const warn = warning || (risk.level === 'high' ? risk.reasons[0] : null);
+
+  console.log();
+  console.log(commandBox(command, explanation, warn));
+
+  const blocked = risk.level === 'high' && !config?.allowDangerous;
+  const choice = await selectMenu([
+    { label: 'Execute', key: 'e', disabled: blocked },
+    { label: 'Copy', key: 'c' },
+    { label: 'Insert', key: 'i' },
+    { label: 'Cancel', key: 'q' },
+  ]);
+
+  switch (choice) {
+    case 'e': {
+      const { code, output } = await runCommand(command, config, { tokenUsage: _tokenUsage });
+      if (code !== 0) {
+        // ─── Error recovery ──────────────────────────────────────────
+        const recovered = await handleFailedCommand(command, output, code, config, context);
+        if (recovered) return; // successfully handled, don't exit with error
+      }
+      cleanExit(code);
+      break;
+    }
+    case 'c': {
+      if (copyToClipboard(command)) console.log(`  ${green(symbols.check)} ${dim('copied')}`);
+      else console.log(`  ${dim(command)}`);
+      break;
+    }
+    case 'i': console.log(`\n${command}\n`); break;
+    default: console.log(`  ${dim('cancelled')}`); break;
+  }
+}
+
+// ─── Clean exit helper ──────────────────────────────────────────────────────
+
+function cleanExit(code) {
+  // Ensure raw mode is off and cursor is visible before exiting
+  try {
+    if (process.stdin.isTTY && process.stdin.isRaw) {
+      process.stdin.setRawMode(false);
+    }
+    process.stdin.pause();
+    process.stdout.write('\x1b[?25h'); // show cursor
+  } catch { /* ignore */ }
+  process.exit(code);
+}
+
+// ─── Error recovery after failed command ────────────────────────────────────
+// Returns true if the error was handled (user chose fix/retry), false otherwise
+
+async function handleFailedCommand(command, output, code, config, context) {
+  console.log();
+  const recovery = await selectMenu([
+    { label: 'Fix it', key: 'f' },
+    { label: 'Retry', key: 'r' },
+    { label: 'Copy error', key: 'c' },
+    { label: 'Exit', key: 'q' },
+  ]);
+
+  if (recovery === 'f') {
+    // Ask the LLM for a fix based on the error output
+    const { queryLLM } = require('./llm');
+
+    // Add the failure to session so LLM has context
+    addEntry(command, output, code, 'auto-fix');
+
+    const errorSnippet = output.length > 500 ? output.slice(-500) : output;
+    const fixPrompt = `The previous command failed. Fix it.\nCommand: ${command}\nError (exit ${code}):\n${errorSnippet}`;
+
+    const spin = new Spinner('fixing...').start();
+    try {
+      const fixResult = await queryLLM(fixPrompt, context, config, 'quick');
+      spin.succeed('done');
+
+      if (fixResult?.command) {
+        // Recurse into interactive mode with the new suggestion
+        await interactiveMode(fixResult, config, context);
+        return true;
+      } else {
+        printError('Could not generate a fix. Try rephrasing your request.');
+        return false;
+      }
+    } catch (err) {
+      spin.fail(err.message);
+      return false;
+    }
+  }
+
+  if (recovery === 'r') {
+    const { code: retryCode, output: retryOutput } = await runCommand(command, config);
+    if (retryCode !== 0) {
+      return await handleFailedCommand(command, retryOutput, retryCode, config, context);
+    }
+    cleanExit(retryCode);
+    return true;
+  }
+
+  if (recovery === 'c') {
+    const errorText = `$ ${command}\n${output}`;
+    if (copyToClipboard(errorText)) {
+      console.log(`  ${green(symbols.check)} ${dim('error copied')}`);
+    } else {
+      console.log(`  ${dim(output.slice(-300))}`);
+    }
+    return false;
+  }
+
+  // 'q' or null — just exit
+  return false;
+}
+
+// ─── Auto-execute ───────────────────────────────────────────────────────────
+
+async function executeMode(result, config) {
+  const { command: rawCommand, explanation, warning, _tokenUsage } = result;
+  const command = stripShellWrapper(rawCommand);
+  const risk = analyzeRisk(command);
+
+  console.log();
+  console.log(commandBox(command, explanation, warning));
+
+  if (risk.level === 'high' || warning) {
+    console.log(`  ${red(symbols.warning)} ${bold('Blocked.')} Use interactive mode.`);
+    cleanExit(1);
+  }
+
+  const { code } = await runCommand(command, config, { tokenUsage: _tokenUsage });
+  cleanExit(code);
+}
+
+module.exports = { runCommand, copyToClipboard, interactiveMode, executeMode, handleFailedCommand, cleanExit, detectBestShell, stripShellWrapper };

package/lib/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+module.exports = {
+  ...require('./config'),
+  ...require('./context'),
+  ...require('./session'),
+  ...require('./llm'),
+  ...require('./executor'),
+  ...require('./planner'),
+  ...require('./safety'),
+  ...require('./menu'),
+  ...require('./renderer'),
+  ...require('./colors'),
+  ...require('./ui'),
+  ...require('./tokens'),
+};