autohand-cli 0.8.2 → 0.9.0

package/dist/{chunk-33RSHBDH.js → chunk-VKBIE6I6.js}

@@ -1,14 +1,14 @@
 import {
   configureSearch,
   getSearchConfig
-} from "./chunk-SAHBLB3E.js";
+} from "./chunk-FP46B4X3.js";
 import {
   showModal,
   showPassword
-} from "./chunk-YZXUDM5X.js";
+} from "./chunk-DLP436GI.js";
 import {
   saveConfig
-} from "./chunk-P47WPOXN.js";
+} from "./chunk-3UT7R3XV.js";
 
 // src/commands/search.ts
 import chalk from "chalk";
@@ -19,12 +19,22 @@ async function search(ctx) {
   console.log(chalk.gray(`Current provider: ${chalk.cyan(currentConfig.provider)}`));
   const braveKeySet = !!(currentConfig.braveApiKey || process.env.BRAVE_SEARCH_API_KEY);
   const parallelKeySet = !!(currentConfig.parallelApiKey || process.env.PARALLEL_API_KEY);
+  const exaKeySet = !!(currentConfig.exaApiKey || process.env.EXA_API_KEY);
   console.log(chalk.gray(`Brave API key: ${braveKeySet ? chalk.green("configured") : chalk.yellow("not set")}`));
   console.log(chalk.gray(`Parallel API key: ${parallelKeySet ? chalk.green("configured") : chalk.yellow("not set")}`));
+  console.log(chalk.gray(`Exa API key: ${exaKeySet ? chalk.green("configured") : chalk.yellow("not set")}`));
   console.log();
   const providerOptions = [
     {
-      label: `Google ${chalk.gray("(no API key required, recommended default)")}`,
+      label: `Browser Profile ${chalk.gray("(uses your Chrome/Brave cookies - no API key)")}`,
+      value: "browser-profile"
+    },
+    {
+      label: `Exa.ai ${chalk.gray("(requires API key)")} ${exaKeySet ? chalk.green("\u2713") : ""}`,
+      value: "exa"
+    },
+    {
+      label: `Google ${chalk.gray("(no API key required)")}`,
       value: "google"
     },
     {
@@ -53,6 +63,19 @@ async function search(ctx) {
     const provider = result.value;
     let braveApiKey = currentConfig.braveApiKey;
     let parallelApiKey = currentConfig.parallelApiKey;
+    let exaApiKey = currentConfig.exaApiKey;
+    if (provider === "exa" && !exaKeySet) {
+      console.log(chalk.gray("\nGet your Exa.ai API key at: https://exa.ai\n"));
+      const apiKey = await showPassword({
+        title: "Enter Exa.ai API key:"
+      });
+      if (apiKey?.trim()) {
+        exaApiKey = apiKey.trim();
+      } else {
+        console.log(chalk.yellow("No API key entered. Exa.ai Search will not work without an API key."));
+        return null;
+      }
+    }
     if (provider === "brave" && !braveKeySet) {
       console.log(chalk.gray("\nGet your free Brave Search API key at: https://brave.com/search/api/\n"));
       const apiKey = await showPassword({
@@ -80,13 +103,15 @@ async function search(ctx) {
     configureSearch({
       provider,
       braveApiKey,
-      parallelApiKey
+      parallelApiKey,
+      exaApiKey
     });
     if (config) {
       config.search = {
         provider,
         braveApiKey,
-        parallelApiKey
+        parallelApiKey,
+        exaApiKey
       };
       await saveConfig(config);
       console.log(chalk.green(`
@@ -96,6 +121,12 @@ async function search(ctx) {
 \u2713 Search provider set to ${provider} (session only)`));
     }
     switch (provider) {
+      case "browser-profile":
+        console.log(chalk.gray("Browser Profile Search is now active. Uses your Chrome/Brave cookies for better results."));
+        break;
+      case "exa":
+        console.log(chalk.gray("Exa.ai Search is now active with neural search capabilities."));
+        break;
       case "google":
         console.log(chalk.gray("Google Search is now active. No API key required."));
         break;
@@ -116,7 +147,7 @@ async function search(ctx) {
 }
 var metadata = {
   command: "/search",
-  description: "configure web search provider (google, brave, duckduckgo, parallel)",
+  description: "configure web search provider (browser-profile, exa, google, brave, duckduckgo, parallel)",
   implemented: true
 };
 

package/dist/{chunk-CWMZKFTT.js → chunk-VRMZO6TB.js}

@@ -1,19 +1,20 @@
 import {
   package_default
-} from "./chunk-T73IDKDF.js";
+} from "./chunk-3PXKRVCW.js";
 import {
   showConfirm,
   showModal
-} from "./chunk-YZXUDM5X.js";
+} from "./chunk-DLP436GI.js";
 import {
   AUTOHAND_PATHS
-} from "./chunk-EGFT4PGW.js";
+} from "./chunk-TWQDAUZU.js";
 import {
   t
-} from "./chunk-APIXPPMT.js";
+} from "./chunk-CBFH2J3O.js";
 
 // src/commands/share.ts
 import chalk from "chalk";
+import { spawnSync } from "child_process";
 import ora from "ora";
 
 // src/share/costEstimator.ts
@@ -159,8 +160,8 @@ function serializeSession(session, options) {
   };
   let usage;
   if (options.totalTokens && options.totalTokens > 0) {
-    const inputTokens = Math.floor(options.totalTokens * 0.3);
-    const outputTokens = options.totalTokens - inputTokens;
+    const inputTokens = options.inputTokens && options.inputTokens > 0 ? options.inputTokens : Math.floor(options.totalTokens * 0.3);
+    const outputTokens = options.outputTokens && options.outputTokens > 0 ? options.outputTokens : options.totalTokens - inputTokens;
     usage = {
       totalTokens: options.totalTokens,
       inputTokens,
@@ -218,8 +219,11 @@ var DEFAULT_CONFIG = {
   cliVersion: package_default.version
 };
 var ShareApiClient = class {
+  config;
+  queuePath;
+  deviceIdPath;
+  deviceId = null;
   constructor(configOverrides) {
-    this.deviceId = null;
     this.config = { ...DEFAULT_CONFIG, ...configOverrides };
     const dataDir = path.join(AUTOHAND_PATHS.config, "share");
     this.queuePath = path.join(dataDir, "queue.json");
@@ -515,6 +519,21 @@ async function execute(_args, context) {
     console.log(chalk.gray("Cancelled."));
     return;
   }
+  let gitDiffContent;
+  try {
+    const result = spawnSync("git", ["diff", "HEAD"], {
+      cwd: context.workspaceRoot,
+      encoding: "utf8",
+      timeout: 1e4
+    });
+    if (result.status === 0 && result.stdout.trim()) {
+      gitDiffContent = result.stdout;
+    }
+  } catch {
+  }
+  const userId = context.config?.auth?.user?.id;
+  const inputTokens = context.getInputTokensUsed?.() ?? 0;
+  const outputTokens = context.getOutputTokensUsed?.() ?? 0;
   console.log();
   const spinner = ora(t("commands.share.generating")).start();
   try {
@@ -522,8 +541,12 @@ async function execute(_args, context) {
       model: context.model,
       provider: context.provider,
       totalTokens,
+      inputTokens,
+      outputTokens,
       visibility,
-      deviceId
+      deviceId,
+      gitDiff: gitDiffContent,
+      userId
     });
     const response = await client.createShare(payload);
     spinner.stop();

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
+ */