autohand-cli 0.8.2 → 0.9.0

package/dist/chunk-3LJJG5YY.cjs

@@ -0,0 +1,387 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkXF2WIKHRcjs = require('./chunk-XF2WIKHR.cjs');
+
+// src/startup/checks.ts
+var _child_process = require('child_process');
+var _fs = require('fs');
+var _os = require('os'); var _os2 = _interopRequireDefault(_os);
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+var GIT_COMMAND_TIMEOUT_MS = 5e3;
+var toolCheckResultsPromise;
+function getCurrentBunVersion() {
+  return process.versions.bun;
+}
+var REQUIRED_TOOLS = [
+  {
+    name: "git",
+    command: "git",
+    versionFlag: "--version",
+    required: true,
+    description: "Version control (required for file tracking, undo, and git operations)",
+    installHints: {
+      darwin: "brew install git",
+      linux: "sudo apt install git  # or: sudo dnf install git",
+      win32: "winget install Git.Git  # or download from https://git-scm.com"
+    }
+  },
+  {
+    name: "ripgrep",
+    command: "rg",
+    versionFlag: "--version",
+    required: false,
+    description: "Fast code search (recommended for better search performance)",
+    installHints: {
+      darwin: "brew install ripgrep",
+      linux: "sudo apt install ripgrep  # or: cargo install ripgrep",
+      win32: "winget install BurntSushi.ripgrep  # or: scoop install ripgrep"
+    }
+  }
+];
+var OPTIONAL_TOOLS = [
+  {
+    name: "node",
+    command: "node",
+    versionFlag: "--version",
+    required: false,
+    description: "Node.js runtime (for npm/yarn package management)",
+    installHints: {
+      darwin: "brew install node  # or: nvm install node",
+      linux: "sudo apt install nodejs  # or: nvm install node",
+      win32: "winget install OpenJS.NodeJS  # or download from https://nodejs.org"
+    },
+    minVersion: "18.0.0"
+  },
+  {
+    name: "bun",
+    command: "bun",
+    versionFlag: "--version",
+    required: false,
+    description: "Bun runtime (fast JavaScript/TypeScript runtime)",
+    installHints: {
+      darwin: "curl -fsSL https://bun.sh/install | bash",
+      linux: "curl -fsSL https://bun.sh/install | bash",
+      win32: 'powershell -c "irm bun.sh/install.ps1 | iex"'
+    }
+  }
+];
+function checkTool(tool) {
+  const platform = _os2.default.platform();
+  const installHint = tool.installHints[platform] || tool.installHints.linux;
+  const command = tool.command === "rg" ? _chunkXF2WIKHRcjs.resolveRipgrepCommand.call(void 0, ) : tool.command;
+  const currentBunVersion = tool.command === "bun" ? getCurrentBunVersion() : void 0;
+  if (tool.command === "bun") {
+    return Promise.resolve({
+      name: tool.name,
+      installed: currentBunVersion !== void 0,
+      version: currentBunVersion,
+      required: tool.required,
+      description: tool.description,
+      installHint: currentBunVersion === void 0 ? installHint : void 0
+    });
+  }
+  return new Promise((resolve) => {
+    try {
+      const proc = _child_process.spawn.call(void 0, command, [tool.versionFlag], {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      const timeout = setTimeout(() => {
+        proc.kill();
+        resolve({
+          name: tool.name,
+          installed: false,
+          required: tool.required,
+          description: tool.description,
+          installHint
+        });
+      }, 5e3);
+      _optionalChain([proc, 'access', _ => _.stdout, 'optionalAccess', _2 => _2.on, 'call', _3 => _3("data", (chunk) => {
+        stdout += chunk.toString();
+      })]);
+      _optionalChain([proc, 'access', _4 => _4.stderr, 'optionalAccess', _5 => _5.on, 'call', _6 => _6("data", (chunk) => {
+        stderr += chunk.toString();
+      })]);
+      proc.on("close", (code) => {
+        clearTimeout(timeout);
+        if (code === 0) {
+          const output = (stdout || stderr).trim();
+          const versionMatch = output.match(/(\d+\.\d+(\.\d+)?)/);
+          const version = versionMatch ? versionMatch[1] : "unknown";
+          resolve({
+            name: tool.name,
+            installed: true,
+            version,
+            required: tool.required,
+            description: tool.description
+          });
+        } else {
+          resolve({
+            name: tool.name,
+            installed: false,
+            required: tool.required,
+            description: tool.description,
+            installHint
+          });
+        }
+      });
+      proc.on("error", () => {
+        clearTimeout(timeout);
+        resolve({
+          name: tool.name,
+          installed: false,
+          required: tool.required,
+          description: tool.description,
+          installHint
+        });
+      });
+    } catch (e2) {
+      resolve({
+        name: tool.name,
+        installed: false,
+        required: tool.required,
+        description: tool.description,
+        installHint
+      });
+    }
+  });
+}
+function checkStartupTools() {
+  toolCheckResultsPromise ??= Promise.all(
+    [...REQUIRED_TOOLS, ...OPTIONAL_TOOLS].map((tool) => checkTool(tool))
+  );
+  return toolCheckResultsPromise;
+}
+async function checkWorkspaceWritable(workspaceRoot) {
+  try {
+    const testFile = `${workspaceRoot}/.autohand-write-test-${Date.now()}`;
+    await _fsextra2.default.writeFile(testFile, "test");
+    await _fsextra2.default.remove(testFile);
+    return { writable: true };
+  } catch (error) {
+    return {
+      writable: false,
+      error: `Cannot write to workspace: ${error.message}`
+    };
+  }
+}
+async function validateWorkspacePath(workspaceRoot) {
+  try {
+    if (!await _fsextra2.default.pathExists(workspaceRoot)) {
+      return {
+        valid: false,
+        error: `Workspace path does not exist: ${workspaceRoot}`
+      };
+    }
+    const stats = await _fsextra2.default.stat(workspaceRoot);
+    if (!stats.isDirectory()) {
+      return {
+        valid: false,
+        error: `Workspace path is not a directory: ${workspaceRoot}`
+      };
+    }
+    await _fsextra2.default.access(workspaceRoot, _fs.constants.R_OK | _fs.constants.W_OK);
+    return { valid: true };
+  } catch (error) {
+    return {
+      valid: false,
+      error: `Cannot access workspace: ${error.message}`
+    };
+  }
+}
+function isEmptyDirectory(dir) {
+  try {
+    const entries = _fsextra2.default.readdirSync(dir);
+    const significantEntries = entries.filter((e) => !e.startsWith(".") || e === ".git");
+    return significantEntries.length === 0;
+  } catch (e3) {
+    return false;
+  }
+}
+function runGitCommand(args, cwd) {
+  return new Promise((resolve) => {
+    try {
+      const proc = _child_process.spawn.call(void 0, "git", args, { cwd, stdio: ["pipe", "pipe", "pipe"] });
+      let stdout = "";
+      const timeout = setTimeout(() => {
+        proc.kill();
+        resolve(void 0);
+      }, GIT_COMMAND_TIMEOUT_MS);
+      _optionalChain([proc, 'access', _7 => _7.stdout, 'optionalAccess', _8 => _8.on, 'call', _9 => _9("data", (chunk) => {
+        stdout += chunk.toString();
+      })]);
+      proc.on("close", (code) => {
+        clearTimeout(timeout);
+        resolve(code === 0 ? stdout.trim() : void 0);
+      });
+      proc.on("error", () => {
+        clearTimeout(timeout);
+        resolve(void 0);
+      });
+    } catch (e4) {
+      resolve(void 0);
+    }
+  });
+}
+async function getGitBranch(workspaceRoot) {
+  const headBranch = readGitHeadBranch(workspaceRoot);
+  if (headBranch) return headBranch;
+  const branch = await runGitCommand(["rev-parse", "--abbrev-ref", "HEAD"], workspaceRoot);
+  if (branch) return branch;
+  return runGitCommand(["symbolic-ref", "--short", "HEAD"], workspaceRoot);
+}
+function readGitHeadBranch(workspaceRoot) {
+  try {
+    const head = _fsextra2.default.readFileSync(`${workspaceRoot}/.git/HEAD`, "utf8").trim();
+    const refPrefix = "ref: refs/heads/";
+    if (head.startsWith(refPrefix)) {
+      const branch = head.slice(refPrefix.length).trim();
+      return branch || void 0;
+    }
+  } catch (e5) {
+    return void 0;
+  }
+  return void 0;
+}
+async function checkGitRepo(workspaceRoot) {
+  const gitDirExists = _fsextra2.default.existsSync(`${workspaceRoot}/.git`);
+  if (gitDirExists) {
+    if (!_fsextra2.default.existsSync(`${workspaceRoot}/.git/HEAD`)) {
+      return { isGitRepo: true };
+    }
+    const branch = await getGitBranch(workspaceRoot);
+    return {
+      isGitRepo: true,
+      branch
+    };
+  }
+  if (isEmptyDirectory(workspaceRoot)) {
+    const initResult = await runGitCommand(["init"], workspaceRoot);
+    if (initResult !== void 0 || _fsextra2.default.existsSync(`${workspaceRoot}/.git/HEAD`)) {
+      if (_os2.default.platform() === "darwin") {
+        try {
+          const gitignorePath = `${workspaceRoot}/.gitignore`;
+          if (!_fsextra2.default.existsSync(gitignorePath)) {
+            _fsextra2.default.writeFileSync(gitignorePath, ".DS_Store\n");
+          }
+        } catch (e6) {
+        }
+      }
+      const branch = await getGitBranch(workspaceRoot) || "main";
+      return {
+        isGitRepo: true,
+        branch,
+        initialized: true
+      };
+    }
+  }
+  return { isGitRepo: false };
+}
+function getPackageManagerHint() {
+  const platform = _os2.default.platform();
+  switch (platform) {
+    case "darwin":
+      return "Homebrew (brew)";
+    case "linux":
+      return "apt, dnf, or your distro package manager";
+    case "win32":
+      return "winget, scoop, or chocolatey";
+    default:
+      return "your system package manager";
+  }
+}
+async function runStartupChecks(workspaceRoot) {
+  const warnings = [];
+  const [toolResults, workspaceCheck, gitCheck] = await Promise.all([
+    checkStartupTools(),
+    checkWorkspaceWritable(workspaceRoot),
+    checkGitRepo(workspaceRoot)
+  ]);
+  for (const result of toolResults) {
+    if (!result.installed && result.required) {
+      warnings.push(`Required tool '${result.name}' is not installed`);
+    }
+  }
+  if (!workspaceCheck.writable) {
+    warnings.push(workspaceCheck.error || "Workspace is not writable");
+  }
+  const allRequiredMet = toolResults.filter((r) => r.required).every((r) => r.installed);
+  return {
+    tools: toolResults,
+    workspace: {
+      path: workspaceRoot,
+      writable: workspaceCheck.writable,
+      isGitRepo: gitCheck.isGitRepo,
+      branch: gitCheck.branch,
+      initialized: gitCheck.initialized,
+      error: workspaceCheck.error
+    },
+    allRequiredMet,
+    warnings
+  };
+}
+function printStartupCheckResults(results, verbose = false) {
+  const missingRequired = results.tools.filter((t) => t.required && !t.installed);
+  const missingOptional = results.tools.filter((t) => !t.required && !t.installed);
+  if (results.workspace.initialized) {
+    console.log(_chalk2.default.green("\u2713 Initialized git repository"));
+    console.log();
+  }
+  if (missingRequired.length === 0 && !verbose) {
+    return;
+  }
+  console.log();
+  if (missingRequired.length > 0) {
+    console.log(_chalk2.default.red.bold("\u26A0 Missing required tools:"));
+    console.log();
+    for (const tool of missingRequired) {
+      console.log(_chalk2.default.red(`  \u2717 ${tool.name}`));
+      console.log(_chalk2.default.gray(`    ${tool.description}`));
+      console.log(_chalk2.default.cyan(`    Install: ${tool.installHint}`));
+      console.log();
+    }
+  }
+  if (missingOptional.length > 0 && verbose) {
+    console.log(_chalk2.default.yellow("Optional tools not installed:"));
+    for (const tool of missingOptional) {
+      console.log(_chalk2.default.yellow(`  \u25CB ${tool.name}`) + _chalk2.default.gray(` - ${tool.description}`));
+      console.log(_chalk2.default.gray(`    Install: ${tool.installHint}`));
+    }
+    console.log();
+  }
+  if (!results.workspace.writable) {
+    console.log(_chalk2.default.red(`\u26A0 Workspace issue: ${results.workspace.error}`));
+    console.log();
+  }
+  if (verbose) {
+    const installed = results.tools.filter((t) => t.installed);
+    if (installed.length > 0) {
+      console.log(_chalk2.default.green("Installed tools:"));
+      for (const tool of installed) {
+        const version = tool.version ? _chalk2.default.gray(` (${tool.version})`) : "";
+        console.log(_chalk2.default.green(`  \u2713 ${tool.name}${version}`));
+      }
+      console.log();
+    }
+  }
+  if (!results.allRequiredMet) {
+    console.log(_chalk2.default.red.bold("Some required tools are missing. Autohand may not work correctly."));
+    console.log(_chalk2.default.gray(`Use ${getPackageManagerHint()} to install them.`));
+    console.log();
+  }
+}
+
+
+
+
+
+exports.validateWorkspacePath = validateWorkspacePath; exports.runStartupChecks = runStartupChecks; exports.printStartupCheckResults = printStartupCheckResults;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Startup checks - validates required tools and environment
+ */

package/dist/chunk-3OF56EMA.cjs

@@ -0,0 +1,197 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/providers/errors.ts
+var ApiError = class extends Error {
+  
+  
+  
+  
+  
+  constructor(message, code, httpStatus, retryable, retryAfterMs, rawDetail) {
+    super(message);
+    this.name = "ApiError";
+    this.code = code;
+    this.httpStatus = httpStatus;
+    this.retryable = retryable;
+    this.retryAfterMs = retryAfterMs;
+    this.rawDetail = rawDetail;
+  }
+};
+var FRIENDLY_MESSAGES = {
+  context_overflow: "The conversation is too long for this model. Try /undo to remove recent turns or /new to start fresh.",
+  model_not_found: "The requested model was not found. Use /model to select a different one.",
+  invalid_request: "The request was malformed and could not be processed.",
+  auth_failed: "Authentication failed. Please verify your API key in ~/.autohand/config.json.",
+  payment_required: "Payment required. Please check your account balance or billing settings.",
+  access_denied: "Access denied. Your API key may not have permission for this model.",
+  rate_limited: "Rate limit exceeded. Please wait a moment and try again, or choose a different model.",
+  server_error: "The AI service encountered an error. Please try again later.",
+  network_error: "Unable to connect to the AI service. Please check your internet connection.",
+  timeout: "The request timed out. The AI service may be experiencing high load.",
+  cancelled: "Request cancelled.",
+  unknown: "An unexpected error occurred. Please try again."
+};
+var MODEL_NOT_FOUND_PATTERNS = [
+  "invalid model",
+  "model does not exist",
+  "model not found",
+  "no endpoints found for model",
+  "does not exist or you do not have access",
+  // OpenRouter returns "X is not a valid model ID" for bad model names
+  "is not a valid model",
+  // Catch "model 'xyz' not found" where 'not found' is separate from 'model'
+  "' not found",
+  '" not found'
+];
+var CONTEXT_OVERFLOW_PATTERNS = [
+  "maximum context length",
+  "context length exceeded",
+  "context is too long",
+  "prompt is too long",
+  "reduce the length",
+  "payload too large",
+  "context window",
+  "token limit",
+  "tokens exceeds",
+  "too many tokens"
+];
+var CANCEL_PATTERNS = [
+  "cancelled",
+  "canceled",
+  "aborted",
+  "user force closed"
+];
+var NETWORK_PATTERNS = [
+  "econnrefused",
+  "econnreset",
+  "enotfound",
+  "etimedout",
+  "fetch failed",
+  "network",
+  "unable to connect"
+];
+var TIMEOUT_PATTERNS = [
+  "timed out",
+  "timeout"
+];
+function classifyApiError(httpStatus, errorBody, headers) {
+  const lower = errorBody.toLowerCase();
+  if (httpStatus === 401) {
+    return makeError("auth_failed", httpStatus, false, errorBody, headers);
+  }
+  if (httpStatus === 402) {
+    return makeError("payment_required", httpStatus, false, errorBody, headers);
+  }
+  if (httpStatus === 403) {
+    return makeError("access_denied", httpStatus, false, errorBody, headers);
+  }
+  if (httpStatus === 404) {
+    return makeError("model_not_found", httpStatus, false, errorBody, headers);
+  }
+  if (httpStatus === 429) {
+    return makeError("rate_limited", httpStatus, true, errorBody, headers);
+  }
+  if (httpStatus === 504) {
+    return makeError("timeout", httpStatus, true, errorBody, headers);
+  }
+  if (httpStatus >= 500) {
+    return makeError("server_error", httpStatus, true, errorBody, headers);
+  }
+  if (httpStatus === 400) {
+    if (matchesAny(lower, MODEL_NOT_FOUND_PATTERNS)) {
+      return makeError("model_not_found", httpStatus, false, errorBody, headers);
+    }
+    if (matchesAny(lower, CONTEXT_OVERFLOW_PATTERNS)) {
+      return makeError("context_overflow", httpStatus, true, errorBody, headers);
+    }
+    return makeError("invalid_request", httpStatus, false, errorBody, headers);
+  }
+  if (matchesAny(lower, CANCEL_PATTERNS)) {
+    return makeError("cancelled", httpStatus, false, errorBody, headers);
+  }
+  if (matchesAny(lower, TIMEOUT_PATTERNS)) {
+    return makeError("timeout", httpStatus, true, errorBody, headers);
+  }
+  if (matchesAny(lower, NETWORK_PATTERNS)) {
+    return makeError("network_error", httpStatus, true, errorBody, headers);
+  }
+  if (httpStatus === 0 || httpStatus === void 0) {
+    if (matchesAny(lower, MODEL_NOT_FOUND_PATTERNS)) {
+      return makeError("model_not_found", httpStatus, false, errorBody, headers);
+    }
+    if (matchesAny(lower, CONTEXT_OVERFLOW_PATTERNS)) {
+      return makeError("context_overflow", httpStatus, true, errorBody, headers);
+    }
+  }
+  return makeError("unknown", httpStatus, true, errorBody, headers);
+}
+function matchesAny(lower, patterns) {
+  return patterns.some((p) => lower.includes(p));
+}
+function stripHtmlFromBody(body) {
+  if (!/<[a-z/][\s\S]*>/i.test(body)) {
+    return body;
+  }
+  return body.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+}
+function makeError(code, httpStatus, retryable, rawBody, headers) {
+  const friendlyMessage = FRIENDLY_MESSAGES[code];
+  const displayBody = rawBody ? stripHtmlFromBody(rawBody) : "";
+  const message = displayBody ? `${friendlyMessage}
+${displayBody}` : friendlyMessage;
+  const retryAfterMs = _nullishCoalesce(parseRetryAfter(headers), () => ( inferRetryAfterFromBody(code, rawBody)));
+  return new ApiError(message, code, httpStatus, retryable, retryAfterMs, rawBody);
+}
+function inferRetryAfterFromBody(code, rawBody) {
+  if (code !== "rate_limited") {
+    return void 0;
+  }
+  const rpmMatch = rawBody.match(/limited to\s+(\d+)\s+requests?\s+per\s+minute/i);
+  if (rpmMatch) {
+    const rpm = Number(rpmMatch[1]);
+    if (Number.isFinite(rpm) && rpm > 0) {
+      return Math.ceil(6e4 / rpm);
+    }
+  }
+  const secondsMatch = rawBody.match(/retry (?:after|in)\s+(\d+)\s+seconds?/i);
+  if (secondsMatch) {
+    const seconds = Number(secondsMatch[1]);
+    if (Number.isFinite(seconds) && seconds > 0) {
+      return seconds * 1e3;
+    }
+  }
+  return void 0;
+}
+function sanitizeModelId(raw) {
+  return raw.replace(/\x1b\[20[01]~/g, "").replace(/\[20[01]~/g, "").replace(/[\x00-\x1f\x7f]/g, "").trim();
+}
+function parseRetryAfter(headers) {
+  if (!headers) return void 0;
+  const value = headers.get("retry-after");
+  if (!value) return void 0;
+  const seconds = Number(value);
+  if (!Number.isNaN(seconds) && seconds > 0) {
+    return seconds * 1e3;
+  }
+  const dateMs = Date.parse(value);
+  if (!Number.isNaN(dateMs)) {
+    const delayMs = dateMs - Date.now();
+    return delayMs > 0 ? delayMs : void 0;
+  }
+  return void 0;
+}
+
+
+
+
+
+exports.ApiError = ApiError; exports.classifyApiError = classifyApiError; exports.sanitizeModelId = sanitizeModelId;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Centralized API error classification.
+ *
+ * Every provider (OpenRouter, Azure, MLX, Ollama, LLMGateway) and every
+ * consumer (agent.ts, RPC adapter, ACP adapter) delegates to this module
+ * so error handling logic lives in one place.
+ */

package/dist/chunk-3PXKRVCW.js

@@ -0,0 +1,108 @@
+// package.json
+var package_default = {
+  name: "autohand-cli",
+  version: "0.9.0",
+  license: "Apache-2.0",
+  description: "Autohand Code CLI is a fast, terminal-native AI coding agent for planning, editing, testing, and automating software work.",
+  repository: {
+    type: "git",
+    url: "https://github.com/autohandai/code-cli.git"
+  },
+  homepage: "https://autohand.ai/cli/",
+  bugs: {
+    url: "https://github.com/autohandai/code-cli/issues"
+  },
+  type: "module",
+  bin: {
+    autohand: "dist/index.js"
+  },
+  main: "dist/index.js",
+  files: [
+    "dist",
+    "assets"
+  ],
+  scripts: {
+    go: './install-local.sh && echo "COMPLETED"',
+    build: "tsup",
+    dev: 'env -i PATH="/Users/igorcosta/.bun/bin:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin" HOME="$HOME" bun src/index.ts',
+    typecheck: "tsc --noEmit",
+    lint: "eslint .",
+    proof: "eslint . && tsc --noEmit && node --max-old-space-size=8192 ./node_modules/vitest/vitest.mjs run",
+    test: "node --max-old-space-size=8192 ./node_modules/vitest/vitest.mjs run",
+    "test:ci": "node --max-old-space-size=8192 ./node_modules/vitest/vitest.mjs run --pool=threads --exclude 'tests/tuistory/**/*.tuistory.test.ts'",
+    "test:tuistory": "node --max-old-space-size=4096 ./node_modules/vitest/vitest.mjs run --config vitest.tuistory.config.ts",
+    "proof:build-tuistory": "tsup && node --max-old-space-size=4096 ./node_modules/vitest/vitest.mjs run --config vitest.tuistory.config.ts",
+    start: "node dist/index.js",
+    "compile:macos-arm64": "bun build ./src/index.ts --compile --target=bun-darwin-arm64 --outfile ./binaries/autohand-macos-arm64",
+    "compile:macos-x64": "bun build ./src/index.ts --compile --target=bun-darwin-x64 --outfile ./binaries/autohand-macos-x64",
+    "compile:linux-x64": "bun build ./src/index.ts --compile --target=bun-linux-x64 --outfile ./binaries/autohand-linux-x64",
+    "compile:linux-arm64": "bun build ./src/index.ts --compile --target=bun-linux-arm64 --outfile ./binaries/autohand-linux-arm64",
+    "compile:windows-x64": "bun build ./src/index.ts --compile --target=bun-windows-x64 --outfile ./binaries/autohand-windows-x64.exe",
+    "compile:all": "bun run compile:macos-arm64 && bun run compile:macos-x64 && bun run compile:linux-x64 && bun run compile:linux-arm64 && bun run compile:windows-x64",
+    link: "bun link",
+    translate: "tsx scripts/generate-translations.ts"
+  },
+  keywords: [
+    "cli",
+    "llm",
+    "agent",
+    "agentic",
+    "autohand"
+  ],
+  engines: {
+    node: ">=22.0.0"
+  },
+  dependencies: {
+    "@agentclientprotocol/sdk": "0.19.1",
+    "@ff-labs/fff-bun": "0.6.4",
+    chalk: "^5.6.2",
+    commander: "^14.0.3",
+    diff: "^9.0.0",
+    dotenv: "^17.4.2",
+    "fs-extra": "^11.3.4",
+    ignore: "^7.0.5",
+    ink: "^7.0.1",
+    "ink-spinner": "^5.0.0",
+    minimatch: "^10.2.5",
+    "node-notifier": "^10.0.1",
+    "node-pty": "^1.1.0",
+    open: "^11.0.0",
+    ora: "^9.4.0",
+    react: "^19.2.5",
+    sharp: "^0.34.5",
+    "string-width": "^8.2.0",
+    "terminal-link": "^5.0.0",
+    yaml: "^2.8.3",
+    zod: "^4.3.6"
+  },
+  trustedDependencies: [
+    "node-pty",
+    "bun"
+  ],
+  devDependencies: {
+    "@types/diff": "^8.0.0",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^25.6.0",
+    "@types/node-notifier": "^8.0.5",
+    "@types/react": "^19.2.5",
+    "@typescript-eslint/eslint-plugin": "^8.59.0",
+    "@typescript-eslint/parser": "^8.59.0",
+    eslint: "^10.2.1",
+    "ink-testing-library": "^4.0.0",
+    memfs: "^4.57.2",
+    "node-gyp": "^12.3.0",
+    "strip-ansi": "^7.2.0",
+    tsup: "^8.5.1",
+    tsx: "^4.21.0",
+    tuistory: "0.4.0",
+    typescript: "^6.0.3",
+    vitest: "^4.1.5"
+  },
+  overrides: {
+    "ansi-styles": "^6.2.3"
+  }
+};
+
+export {
+  package_default
+};