autohand-cli 0.8.3 → 0.9.1

package/dist/chunk-VUGOOGHB.js

@@ -0,0 +1,400 @@
+// src/ui/shellCommand.ts
+import { execSync, spawn } from "child_process";
+import { readdirSync } from "fs";
+import path from "path";
+var DEFAULT_SHELL_TIMEOUT = 3e4;
+var SHELL_HOT_TIP_SUGGESTIONS = [
+  "git status",
+  "ls -la",
+  "bun test",
+  "bun run lint"
+];
+var SHELL_COMMAND_CANDIDATES = [
+  "git",
+  "bun",
+  "npm",
+  "pnpm",
+  "yarn",
+  "node",
+  "python",
+  "python3",
+  "ls",
+  "cd",
+  "mkdir",
+  "cat",
+  "rg",
+  "grep",
+  "find",
+  "touch",
+  "cp",
+  "mv",
+  "rm",
+  "pwd"
+];
+var COMMAND_TEMPLATE_MAP = {
+  git: ["git status", "git diff", "git log --oneline -5"],
+  bun: ["bun test", "bun run lint", "bun run build"],
+  npm: ["npm test", "npm run lint", "npm run build"],
+  pnpm: ["pnpm test", "pnpm lint", "pnpm build"],
+  yarn: ["yarn test", "yarn lint", "yarn build"],
+  ls: ["ls -la"],
+  cd: ["cd ./", "cd .."],
+  mkdir: ["mkdir -p "],
+  rg: ['rg "TODO" src']
+};
+var PATH_COMPLETION_COMMANDS = /* @__PURE__ */ new Set([
+  "cd",
+  "mkdir",
+  "ls",
+  "cat",
+  "rm",
+  "cp",
+  "mv",
+  "touch"
+]);
+var DIRECTORY_ONLY_PATH_COMMANDS = /* @__PURE__ */ new Set(["cd"]);
+var DIR_ENTRIES_CACHE_TTL_MS = 750;
+var dirEntriesCache = /* @__PURE__ */ new Map();
+function unescapeShellSpaces(value) {
+  return value.replace(/\\ /g, " ");
+}
+function escapeShellSpaces(value) {
+  return value.replace(/ /g, "\\ ");
+}
+function unique(items) {
+  return Array.from(new Set(items));
+}
+function getCachedDirectoryEntries(absDir) {
+  const now = Date.now();
+  const cached = dirEntriesCache.get(absDir);
+  if (cached && cached.expiresAt > now) {
+    return cached.entries;
+  }
+  try {
+    const entries = readdirSync(absDir, { withFileTypes: true });
+    dirEntriesCache.set(absDir, {
+      expiresAt: now + DIR_ENTRIES_CACHE_TTL_MS,
+      entries
+    });
+    return entries;
+  } catch {
+    return [];
+  }
+}
+function completePathToken(rawToken, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const unescapedToken = unescapeShellSpaces(rawToken);
+  const lastSlash = unescapedToken.lastIndexOf("/");
+  const dirPart = lastSlash >= 0 ? unescapedToken.slice(0, lastSlash + 1) : "";
+  const namePrefix = lastSlash >= 0 ? unescapedToken.slice(lastSlash + 1) : unescapedToken;
+  const directoriesOnly = options.directoriesOnly === true;
+  const searchDirAbs = unescapedToken.startsWith("/") ? path.resolve(dirPart || "/") : path.resolve(cwd, dirPart || ".");
+  const matches = getCachedDirectoryEntries(searchDirAbs).filter((entry) => !directoriesOnly || entry.isDirectory()).filter((entry) => entry.name.startsWith(namePrefix)).sort((a, b) => {
+    if (a.isDirectory() !== b.isDirectory()) {
+      return a.isDirectory() ? -1 : 1;
+    }
+    return a.name.localeCompare(b.name);
+  });
+  return matches.map((entry) => {
+    const suffix = entry.isDirectory() ? "/" : "";
+    const completed = `${dirPart}${entry.name}${suffix}`;
+    return escapeShellSpaces(completed);
+  });
+}
+function parseBangInput(line) {
+  const withoutLeading = line.trimStart();
+  if (!withoutLeading.startsWith("!")) {
+    return null;
+  }
+  const commandBody = withoutLeading.slice(1).trimStart();
+  return {
+    commandBody,
+    hasTrailingSpace: /\s$/.test(line)
+  };
+}
+function buildCommandNameSuggestions(commandPrefix) {
+  const prefix = commandPrefix.toLowerCase();
+  const matches = SHELL_COMMAND_CANDIDATES.filter((candidate) => candidate.startsWith(prefix));
+  const exact = SHELL_COMMAND_CANDIDATES.find((candidate) => candidate === prefix);
+  const suggestions = [];
+  if (exact) {
+    const templates = COMMAND_TEMPLATE_MAP[exact] ?? [];
+    suggestions.push(...templates.map((template) => `! ${template}`));
+  }
+  for (const candidate of matches) {
+    suggestions.push(`! ${candidate} `);
+  }
+  return unique(suggestions);
+}
+function buildPathSuggestions(commandName, args, hasTrailingSpace, options = {}) {
+  const normalizedCommand = commandName.toLowerCase();
+  if (!PATH_COMPLETION_COMMANDS.has(normalizedCommand)) {
+    return [];
+  }
+  if (!hasTrailingSpace && args.length > 0 && args[args.length - 1]?.startsWith("-")) {
+    return [];
+  }
+  const targetIndex = hasTrailingSpace ? args.length : Math.max(0, args.length - 1);
+  const rawToken = hasTrailingSpace ? "" : args[targetIndex] ?? "";
+  const completedTokens = completePathToken(rawToken, {
+    ...options,
+    directoriesOnly: DIRECTORY_ONLY_PATH_COMMANDS.has(normalizedCommand)
+  });
+  const result = [];
+  for (const token of completedTokens) {
+    const nextArgs = [...args];
+    if (hasTrailingSpace) {
+      nextArgs.push(token);
+    } else {
+      nextArgs[targetIndex] = token;
+    }
+    const suggestion = `! ${commandName}${nextArgs.length > 0 ? ` ${nextArgs.join(" ")}` : ""}`;
+    result.push(token.endsWith("/") ? suggestion : `${suggestion} `);
+  }
+  return result;
+}
+function getShellCommandSuggestions(line, options = {}) {
+  const parsed = parseBangInput(line);
+  if (!parsed) {
+    return [];
+  }
+  const { commandBody, hasTrailingSpace } = parsed;
+  const limit = Math.max(1, options.limit ?? 5);
+  if (!commandBody) {
+    return SHELL_HOT_TIP_SUGGESTIONS.slice(0, limit).map((value) => `! ${value}`);
+  }
+  const tokens = commandBody.split(/\s+/).filter(Boolean);
+  if (tokens.length === 0) {
+    return SHELL_HOT_TIP_SUGGESTIONS.slice(0, limit).map((value) => `! ${value}`);
+  }
+  const commandName = tokens[0];
+  const args = tokens.slice(1);
+  const commandNameSuggestions = !hasTrailingSpace && tokens.length === 1 ? buildCommandNameSuggestions(commandName) : [];
+  const pathSuggestions = buildPathSuggestions(commandName, args, hasTrailingSpace, options);
+  const templates = (COMMAND_TEMPLATE_MAP[commandName.toLowerCase()] ?? []).map((value) => `! ${value}`);
+  const hotTips = SHELL_HOT_TIP_SUGGESTIONS.map((value) => `! ${value}`);
+  return unique([
+    ...pathSuggestions,
+    ...commandNameSuggestions,
+    ...templates,
+    ...hotTips
+  ]).slice(0, limit);
+}
+function getPrimaryShellCommandSuggestion(line, options = {}) {
+  const [first] = getShellCommandSuggestions(line, { ...options, limit: 1 });
+  return first ?? null;
+}
+async function defaultNodePtyLoader() {
+  try {
+    return await import("node-pty");
+  } catch {
+    return null;
+  }
+}
+var nodePtyLoader = defaultNodePtyLoader;
+function isShellCommand(input) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("!")) {
+    return false;
+  }
+  const command = trimmed.slice(1).trim();
+  return command.length > 0;
+}
+function parseShellCommand(input) {
+  if (!input.trim().startsWith("!")) {
+    return "";
+  }
+  return input.trim().slice(1).trim();
+}
+function isImmediateCommand(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return false;
+  if (isShellCommand(trimmed)) return true;
+  if (trimmed.startsWith("/")) {
+    const command = trimmed.slice(1).trim();
+    if (command.length === 0) return false;
+    const firstToken = trimmed.split(/\s+/, 1)[0] ?? "";
+    const hasNestedSlashes = (firstToken.match(/\//g) || []).length > 1;
+    const isCommonPathPrefix = /^\/(?:Users|home|tmp|var|opt|etc|usr)\//i.test(firstToken);
+    const looksLikeFile = /\.[a-z0-9]{1,5}$/i.test(firstToken);
+    if (hasNestedSlashes || isCommonPathPrefix || looksLikeFile) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+async function executeShellCommandAsync(command, cwd, timeout = DEFAULT_SHELL_TIMEOUT, options = {}) {
+  const trimmedCommand = command.trim();
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let resolved = false;
+    let timedOut = false;
+    let timeoutId;
+    const finish = (result) => {
+      if (resolved) {
+        return;
+      }
+      resolved = true;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      resolve(result);
+    };
+    let child;
+    try {
+      child = spawn(trimmedCommand, {
+        cwd: cwd ?? process.cwd(),
+        shell: true,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (error) {
+      const execError = error;
+      finish({
+        success: false,
+        error: execError.stderr?.toString() || execError.message || "Unknown error"
+      });
+      return;
+    }
+    if (timeout > 0) {
+      timeoutId = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGTERM");
+      }, timeout);
+    }
+    child.stdout?.on("data", (chunk) => {
+      const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      stdout += text;
+      options.onStdout?.(text);
+    });
+    child.stderr?.on("data", (chunk) => {
+      const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      stderr += text;
+      options.onStderr?.(text);
+    });
+    child.once("error", (error) => {
+      finish({
+        success: false,
+        error: stderr || error.stderr?.toString() || error.message || "Unknown error"
+      });
+    });
+    child.once("close", (code, signal) => {
+      if (code === 0) {
+        finish({
+          success: true,
+          output: stdout
+        });
+        return;
+      }
+      const errorMessage = timedOut ? `Command timed out after ${timeout}ms` : stderr || (signal ? `Command terminated by ${signal}` : `Command failed with exit code ${code ?? "unknown"}`);
+      finish({
+        success: false,
+        error: errorMessage
+      });
+    });
+  });
+}
+async function loadNodePty() {
+  return nodePtyLoader();
+}
+function getPtyShellLaunch(command) {
+  if (process.platform === "win32") {
+    const comspec = process.env.ComSpec || "cmd.exe";
+    return {
+      file: comspec,
+      args: ["/d", "/s", "/c", command]
+    };
+  }
+  const shell = process.env.SHELL || "/bin/sh";
+  return {
+    file: shell,
+    args: ["-lc", command]
+  };
+}
+async function executeStreamingShellCommand(command, cwd, options = {}) {
+  const trimmedCommand = command.trim();
+  if (options.background) {
+    return new Promise((resolve) => {
+      let child;
+      try {
+        child = spawn(trimmedCommand, {
+          cwd: cwd ?? process.cwd(),
+          shell: true,
+          detached: true,
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+      } catch (error) {
+        const execError = error;
+        resolve({
+          success: false,
+          error: execError.message || "Unknown error"
+        });
+        return;
+      }
+      child.unref();
+      resolve({
+        success: true,
+        output: "",
+        backgroundPid: child.pid
+      });
+    });
+  }
+  const shouldUsePty = options.preferPty === true && process.stdin.isTTY && process.stdout.isTTY;
+  if (!shouldUsePty) {
+    return executeShellCommandAsync(trimmedCommand, cwd, DEFAULT_SHELL_TIMEOUT, options);
+  }
+  const nodePty = await loadNodePty();
+  if (!nodePty) {
+    return executeShellCommandAsync(trimmedCommand, cwd, DEFAULT_SHELL_TIMEOUT, options);
+  }
+  return new Promise((resolve) => {
+    const { file, args } = getPtyShellLaunch(trimmedCommand);
+    const ptyProcess = nodePty.spawn(file, args, {
+      name: process.env.TERM || "xterm-256color",
+      cols: Math.max(20, options.columns ?? process.stdout.columns ?? 80),
+      rows: Math.max(10, options.rows ?? process.stdout.rows ?? 24),
+      cwd: cwd ?? process.cwd(),
+      env: {
+        ...process.env,
+        AUTOHAND_CLI: "1"
+      }
+    });
+    let output = "";
+    const dataDisposable = ptyProcess.onData((data) => {
+      output += data;
+      options.onStdout?.(data);
+    });
+    const exitDisposable = ptyProcess.onExit((event) => {
+      dataDisposable.dispose();
+      exitDisposable.dispose();
+      const normalized = output.replace(/\r\n/g, "\n");
+      if (event.exitCode === 0) {
+        resolve({
+          success: true,
+          output: normalized
+        });
+        return;
+      }
+      resolve({
+        success: false,
+        error: normalized || `Command failed with exit code ${event.exitCode}`
+      });
+    });
+  });
+}
+
+export {
+  getShellCommandSuggestions,
+  getPrimaryShellCommandSuggestion,
+  isShellCommand,
+  parseShellCommand,
+  isImmediateCommand,
+  executeShellCommandAsync,
+  executeStreamingShellCommand
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */