autohand-cli 0.7.13 → 0.8.0

package/dist/{chunk-63BXZQZW.js → chunk-E23CMMNJ.js}

@@ -1,15 +1,16 @@
 import {
   safePrompt
-} from "./chunk-YHGTBPEC.js";
+} from "./chunk-VNQ5GL34.js";
 import {
   t
-} from "./chunk-NMWEDN4Z.js";
+} from "./chunk-HFMLWH7B.js";
 
 // src/commands/hooks.ts
 import chalk from "chalk";
 var HOOK_EVENTS = [
   "session-start",
   "session-end",
+  "pre-clear",
   "pre-prompt",
   "pre-tool",
   "post-tool",
@@ -27,11 +28,19 @@ var HOOK_EVENTS = [
   "automode:resume",
   "automode:cancel",
   "automode:complete",
-  "automode:error"
+  "automode:error",
+  // Team events
+  "team-created",
+  "teammate-spawned",
+  "teammate-idle",
+  "task-assigned",
+  "task-completed",
+  "team-shutdown"
 ];
 var EVENT_DESCRIPTIONS = {
   "session-start": "When a session begins",
   "session-end": "When a session ends",
+  "pre-clear": "Before memory extraction on /clear or /new",
   "pre-prompt": "Before processing user input",
   "pre-tool": "Before a tool executes",
   "post-tool": "After a tool completes",
@@ -50,7 +59,14 @@ var EVENT_DESCRIPTIONS = {
   "automode:resume": "When auto-mode is resumed",
   "automode:cancel": "When auto-mode is cancelled",
   "automode:complete": "When auto-mode completes",
-  "automode:error": "When auto-mode encounters an error"
+  "automode:error": "When auto-mode encounters an error",
+  // Team events
+  "team-created": "When a team is created",
+  "teammate-spawned": "When a teammate process starts",
+  "teammate-idle": "When a teammate becomes idle",
+  "task-assigned": "When a task is assigned to a teammate",
+  "task-completed": "When a task is marked as done",
+  "team-shutdown": "When team cleanup completes"
 };
 var HOOK_ICONS = {
   // Script-based hooks

package/dist/{chunk-4HA7IHLJ.cjs → chunk-EEGK5DYE.cjs}

@@ -1,15 +1,16 @@
 "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 _chunkBRXIEKJ3cjs = require('./chunk-BRXIEKJ3.cjs');
+var _chunkAMT2UZBIcjs = require('./chunk-AMT2UZBI.cjs');
 
 
-var _chunk2U5HFVROcjs = require('./chunk-2U5HFVRO.cjs');
+var _chunkRVUQKMXXcjs = require('./chunk-RVUQKMXX.cjs');
 
 // src/commands/hooks.ts
 var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
 var HOOK_EVENTS = [
   "session-start",
   "session-end",
+  "pre-clear",
   "pre-prompt",
   "pre-tool",
   "post-tool",
@@ -27,11 +28,19 @@ var HOOK_EVENTS = [
   "automode:resume",
   "automode:cancel",
   "automode:complete",
-  "automode:error"
+  "automode:error",
+  // Team events
+  "team-created",
+  "teammate-spawned",
+  "teammate-idle",
+  "task-assigned",
+  "task-completed",
+  "team-shutdown"
 ];
 var EVENT_DESCRIPTIONS = {
   "session-start": "When a session begins",
   "session-end": "When a session ends",
+  "pre-clear": "Before memory extraction on /clear or /new",
   "pre-prompt": "Before processing user input",
   "pre-tool": "Before a tool executes",
   "post-tool": "After a tool completes",
@@ -50,7 +59,14 @@ var EVENT_DESCRIPTIONS = {
   "automode:resume": "When auto-mode is resumed",
   "automode:cancel": "When auto-mode is cancelled",
   "automode:complete": "When auto-mode completes",
-  "automode:error": "When auto-mode encounters an error"
+  "automode:error": "When auto-mode encounters an error",
+  // Team events
+  "team-created": "When a team is created",
+  "teammate-spawned": "When a teammate process starts",
+  "teammate-idle": "When a teammate becomes idle",
+  "task-assigned": "When a task is assigned to a teammate",
+  "task-completed": "When a task is marked as done",
+  "team-shutdown": "When team cleanup completes"
 };
 var HOOK_ICONS = {
   // Script-based hooks
@@ -119,11 +135,11 @@ function getShortCommand(command) {
 }
 function displayHooksList(allHooks) {
   console.log();
-  console.log(_chalk2.default.bold.cyan(_chunk2U5HFVROcjs.t.call(void 0, "commands.hooks.title")));
+  console.log(_chalk2.default.bold.cyan(_chunkRVUQKMXXcjs.t.call(void 0, "commands.hooks.title")));
   console.log(_chalk2.default.gray("  Lifecycle hooks run shell commands on events"));
   console.log();
   if (allHooks.length === 0) {
-    console.log(_chalk2.default.gray(`  ${_chunk2U5HFVROcjs.t.call(void 0, "commands.hooks.noHooks")}`));
+    console.log(_chalk2.default.gray(`  ${_chunkRVUQKMXXcjs.t.call(void 0, "commands.hooks.noHooks")}`));
     console.log();
     return;
   }
@@ -197,7 +213,7 @@ async function hooks(ctx) {
     const toggleLabel = settings.enabled !== false ? "\u25EF Disable all hooks" : "\u25CF Enable all hooks";
     choices.push({ name: "toggle_global", message: toggleLabel });
   }
-  const actionResult = await _chunkBRXIEKJ3cjs.safePrompt.call(void 0, {
+  const actionResult = await _chunkAMT2UZBIcjs.safePrompt.call(void 0, {
     type: "select",
     name: "action",
     message: "Action",
@@ -233,7 +249,7 @@ async function toggleHooksMulti(manager, allHooks) {
       enabled: h.enabled !== false
     };
   });
-  const result = await _chunkBRXIEKJ3cjs.safePrompt.call(void 0, {
+  const result = await _chunkAMT2UZBIcjs.safePrompt.call(void 0, {
     type: "select",
     name: "selected",
     message: "Toggle hooks (select to enable/disable)",
@@ -259,26 +275,26 @@ async function addHook(manager) {
     name: e,
     message: `${e} ${_chalk2.default.dim(`- ${EVENT_DESCRIPTIONS[e]}`)}`
   }));
-  const eventResult = await _chunkBRXIEKJ3cjs.safePrompt.call(void 0, {
+  const eventResult = await _chunkAMT2UZBIcjs.safePrompt.call(void 0, {
     type: "select",
     name: "event",
     message: "Event to hook into",
     choices: eventChoices
   });
   if (!eventResult) return;
-  const commandResult = await _chunkBRXIEKJ3cjs.safePrompt.call(void 0, {
+  const commandResult = await _chunkAMT2UZBIcjs.safePrompt.call(void 0, {
     type: "input",
     name: "command",
     message: "Shell command to execute",
     validate: (val) => typeof val === "string" && val.trim().length > 0 || "Command is required"
   });
   if (!commandResult || !commandResult.command) return;
-  const descResult = await _chunkBRXIEKJ3cjs.safePrompt.call(void 0, {
+  const descResult = await _chunkAMT2UZBIcjs.safePrompt.call(void 0, {
     type: "input",
     name: "description",
     message: "Description (optional)"
   });
-  const asyncResult = await _chunkBRXIEKJ3cjs.safePrompt.call(void 0, {
+  const asyncResult = await _chunkAMT2UZBIcjs.safePrompt.call(void 0, {
     type: "confirm",
     name: "async",
     message: "Run asynchronously (non-blocking)?",
@@ -303,7 +319,7 @@ async function removeHook(manager, allHooks) {
       message: `${eventTag} ${desc2}`
     };
   });
-  const selectResult = await _chunkBRXIEKJ3cjs.safePrompt.call(void 0, {
+  const selectResult = await _chunkAMT2UZBIcjs.safePrompt.call(void 0, {
     type: "select",
     name: "hookIndex",
     message: "Select hook to remove",
@@ -315,7 +331,7 @@ async function removeHook(manager, allHooks) {
   const eventHooks = allHooks.filter((h) => h.event === hook.event);
   const eventIndex = eventHooks.indexOf(hook);
   const desc = hook.description || getShortCommand(hook.command);
-  const confirmResult = await _chunkBRXIEKJ3cjs.safePrompt.call(void 0, {
+  const confirmResult = await _chunkAMT2UZBIcjs.safePrompt.call(void 0, {
     type: "confirm",
     name: "confirm",
     message: `Remove "${desc}"?`,
@@ -338,7 +354,7 @@ async function testHook(manager, allHooks) {
       message: `${eventTag} ${desc}`
     };
   });
-  const selectResult = await _chunkBRXIEKJ3cjs.safePrompt.call(void 0, {
+  const selectResult = await _chunkAMT2UZBIcjs.safePrompt.call(void 0, {
     type: "select",
     name: "hookIndex",
     message: "Select hook to test",
@@ -369,7 +385,7 @@ async function testHook(manager, allHooks) {
 }
 var metadata = {
   command: "/hooks",
-  description: _chunk2U5HFVROcjs.t.call(void 0, "commands.hooks.description"),
+  description: _chunkRVUQKMXXcjs.t.call(void 0, "commands.hooks.description"),
   implemented: true
 };
 

package/dist/{chunk-DTFR3WD6.js → chunk-EF4LKUQY.js}

@@ -1,6 +1,6 @@
 import {
   t
-} from "./chunk-NMWEDN4Z.js";
+} from "./chunk-HFMLWH7B.js";
 
 // src/commands/memory.ts
 import chalk from "chalk";

package/dist/{chunk-PWLLLJHU.js → chunk-EGFT4PGW.js}

@@ -26,7 +26,9 @@ var AUTOHAND_PATHS = {
   /** Plan files for plan mode */
   plans: path.join(AUTOHAND_HOME, "plans"),
   /** MCP community registry cache */
-  mcpCache: path.join(AUTOHAND_HOME, "community-mcp", "cache")
+  mcpCache: path.join(AUTOHAND_HOME, "community-mcp", "cache"),
+  /** Auto-report data */
+  reporting: path.join(AUTOHAND_HOME, "reporting")
 };
 var AUTOHAND_FILES = {
   /** Main config file */

package/dist/{chunk-S47TCZDL.js → chunk-EIU7K7CM.js}

@@ -1,22 +1,22 @@
 import {
   DEFAULT_SYNC_CONFIG,
   createSyncService
-} from "./chunk-P5VDZ6PV.js";
+} from "./chunk-3PDTTAKJ.js";
 import {
   getAuthClient
-} from "./chunk-D2XFTCRP.js";
+} from "./chunk-HQ7YZKXE.js";
 import {
   safePrompt
-} from "./chunk-YHGTBPEC.js";
+} from "./chunk-VNQ5GL34.js";
 import {
   saveConfig
-} from "./chunk-ZBIBLOZL.js";
+} from "./chunk-WTNBX2JO.js";
 import {
   AUTH_CONFIG
-} from "./chunk-PWLLLJHU.js";
+} from "./chunk-EGFT4PGW.js";
 import {
   t
-} from "./chunk-NMWEDN4Z.js";
+} from "./chunk-HFMLWH7B.js";
 
 // src/commands/login.ts
 import chalk from "chalk";
@@ -141,7 +141,7 @@ async function checkAndRestoreSyncData(token, userId, config) {
         enabled: true
       }
     });
-    const { getSyncApiClient } = await import("./SyncApiClient-AYXYSOJM.js");
+    const { getSyncApiClient } = await import("./SyncApiClient-LVIO4C2S.js");
     const apiClient = getSyncApiClient();
     const remoteManifest = await apiClient.getRemoteManifest(token);
     if (!remoteManifest || remoteManifest.files.length === 0) {

package/dist/{chunk-BISFR6ZL.js → chunk-EPNYD4NV.js}

@@ -2,7 +2,7 @@ import {
   getCurrentLocale,
   onLanguageChange,
   t
-} from "./chunk-NMWEDN4Z.js";
+} from "./chunk-HFMLWH7B.js";
 
 // src/ui/i18n/I18nContext.tsx
 import { createContext, useContext, useState, useEffect, useMemo } from "react";

package/dist/chunk-EZMINVLU.js

@@ -0,0 +1,123 @@
+// src/utils/gitIgnore.ts
+import fs from "fs-extra";
+import path from "path";
+import ignore from "ignore";
+var GitIgnoreParser = class {
+  constructor(projectRoot, extraPatterns) {
+    this.extraPatterns = extraPatterns;
+    this.cache = /* @__PURE__ */ new Map();
+    this.processedExtraPatterns = [];
+    this.projectRoot = path.resolve(projectRoot);
+    if (this.extraPatterns?.length) {
+      this.processedExtraPatterns = this.processPatterns(this.extraPatterns, ".");
+    }
+  }
+  isIgnored(filePath) {
+    if (!filePath) {
+      return false;
+    }
+    const absoluteFilePath = path.resolve(this.projectRoot, filePath);
+    if (!absoluteFilePath.startsWith(this.projectRoot)) {
+      return false;
+    }
+    const relativePath = path.relative(this.projectRoot, absoluteFilePath);
+    if (!relativePath || relativePath.startsWith("..")) {
+      return false;
+    }
+    const normalizedPath = relativePath.replace(/\\/g, "/");
+    const ig = ignore();
+    ig.add(".git");
+    if (this.globalPatterns === void 0) {
+      const excludeFile = path.join(this.projectRoot, ".git", "info", "exclude");
+      this.globalPatterns = fs.existsSync(excludeFile) ? this.loadPatternsForFile(excludeFile) : [];
+    }
+    ig.add(this.globalPatterns);
+    const pathParts = relativePath.split(path.sep);
+    const dirsToVisit = [];
+    let current = this.projectRoot;
+    dirsToVisit.push(current);
+    for (let i = 0; i < pathParts.length - 1; i++) {
+      current = path.join(current, pathParts[i]);
+      dirsToVisit.push(current);
+    }
+    for (const dir of dirsToVisit) {
+      const relativeDir = path.relative(this.projectRoot, dir);
+      if (relativeDir) {
+        const normalizedDir = relativeDir.replace(/\\/g, "/");
+        const igPlusExtras = ignore().add(ig).add(this.processedExtraPatterns);
+        if (igPlusExtras.ignores(normalizedDir)) {
+          break;
+        }
+      }
+      if (this.cache.has(dir)) {
+        ig.add(this.cache.get(dir) ?? []);
+      } else {
+        const gitignorePath = path.join(dir, ".gitignore");
+        if (fs.existsSync(gitignorePath)) {
+          const patterns = this.loadPatternsForFile(gitignorePath);
+          this.cache.set(dir, patterns);
+          ig.add(patterns);
+        } else {
+          this.cache.set(dir, []);
+        }
+      }
+    }
+    ig.add(this.processedExtraPatterns);
+    return ig.ignores(normalizedPath);
+  }
+  loadPatternsForFile(patternsFilePath) {
+    let content = "";
+    try {
+      content = fs.readFileSync(patternsFilePath, "utf8");
+    } catch {
+      return [];
+    }
+    const isExcludeFile = patternsFilePath.endsWith(path.join(".git", "info", "exclude"));
+    const relativeBaseDir = isExcludeFile ? "." : path.dirname(path.relative(this.projectRoot, patternsFilePath)).split(path.sep).join(path.posix.sep);
+    const rawPatterns = content.split("\n");
+    return this.processPatterns(rawPatterns, relativeBaseDir);
+  }
+  processPatterns(rawPatterns, relativeBaseDir) {
+    return rawPatterns.map((pattern) => pattern.trimStart()).filter((pattern) => pattern && !pattern.startsWith("#")).map((pattern) => this.normalizePattern(pattern, relativeBaseDir)).filter(Boolean);
+  }
+  normalizePattern(pattern, relativeBaseDir) {
+    let p = pattern;
+    const isNegative = p.startsWith("!");
+    if (isNegative) {
+      p = p.slice(1);
+    }
+    const isAnchored = p.startsWith("/");
+    if (isAnchored) {
+      p = p.slice(1);
+    }
+    if (!p) {
+      return "";
+    }
+    let newPattern = p;
+    if (relativeBaseDir && relativeBaseDir !== ".") {
+      if (!isAnchored && !p.includes("/")) {
+        newPattern = path.posix.join("**", p);
+      }
+      newPattern = path.posix.join(relativeBaseDir, newPattern);
+      if (!newPattern.startsWith("/")) {
+        newPattern = "/" + newPattern;
+      }
+    }
+    if (isAnchored && !newPattern.startsWith("/")) {
+      newPattern = "/" + newPattern;
+    }
+    if (isNegative) {
+      newPattern = "!" + newPattern;
+    }
+    return newPattern;
+  }
+};
+
+export {
+  GitIgnoreParser
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-LYMTYC67.js → chunk-F23EVNJU.js}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-QHPFA6OE.js";
 import {
   safePrompt
-} from "./chunk-YHGTBPEC.js";
+} from "./chunk-VNQ5GL34.js";
 import {
   AUTOHAND_PATHS
-} from "./chunk-PWLLLJHU.js";
+} from "./chunk-EGFT4PGW.js";
 
 // src/commands/skills-new.ts
 import path from "path";

package/dist/chunk-FHK7UDOJ.cjs

@@ -0,0 +1,42 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/commands/message.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var metadata = {
+  command: "/message",
+  description: "Send a direct message to a teammate",
+  implemented: true
+};
+async function message(ctx, args) {
+  if (!ctx.teamManager) {
+    return _chalk2.default.yellow("Team manager not available.");
+  }
+  const team = ctx.teamManager.getTeam();
+  if (!team) {
+    return _chalk2.default.yellow("No active team.");
+  }
+  if (args.length < 2) {
+    return [
+      _chalk2.default.bold("Usage:"),
+      `  ${_chalk2.default.cyan("/message <name> <text>")}`,
+      "",
+      _chalk2.default.gray("Example: /message hunter also check src/legacy/")
+    ].join("\n");
+  }
+  const [targetName, ...rest] = args;
+  const content = rest.join(" ");
+  try {
+    ctx.teamManager.sendMessageTo(targetName, "lead", content);
+    return _chalk2.default.green(`Message sent to ${targetName}.`);
+  } catch (err) {
+    return _chalk2.default.red(err.message);
+  }
+}
+
+
+
+
+exports.metadata = metadata; exports.message = message;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-FMB3TSWP.cjs

@@ -0,0 +1,218 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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; }// src/utils/versionCheck.ts
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _os = require('os'); var _os2 = _interopRequireDefault(_os);
+var GITHUB_REPO = "autohandai/code-cli";
+var GITHUB_API_LATEST_URL = `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`;
+var GITHUB_API_RELEASES_URL = `https://api.github.com/repos/${GITHUB_REPO}/releases?per_page=100`;
+var CACHE_DIR = _path2.default.join(_os2.default.homedir(), ".autohand");
+var DEFAULT_CHECK_INTERVAL_HOURS = 24;
+var REQUEST_TIMEOUT_MS = 3e3;
+function detectChannel(version) {
+  return version.includes("-alpha.") ? "alpha" : "stable";
+}
+function getCacheFile(channel) {
+  return _path2.default.join(CACHE_DIR, `version-check-${channel}.json`);
+}
+function compareVersions(a, b) {
+  const cleanA = a.replace(/^v/, "");
+  const cleanB = b.replace(/^v/, "");
+  const [versionA, preA] = cleanA.split("-");
+  const [versionB, preB] = cleanB.split("-");
+  const partsA = versionA.split(".").map(Number);
+  const partsB = versionB.split(".").map(Number);
+  for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+    const numA = partsA[i] || 0;
+    const numB = partsB[i] || 0;
+    if (numA < numB) return -1;
+    if (numA > numB) return 1;
+  }
+  if (!preA && preB) return 1;
+  if (preA && !preB) return -1;
+  if (preA && preB) {
+    return preA.localeCompare(preB);
+  }
+  return 0;
+}
+function parseReleaseTimestamp(release) {
+  const rawTimestamp = _nullishCoalesce(_nullishCoalesce(release.published_at, () => ( release.created_at)), () => ( null));
+  if (!rawTimestamp) {
+    return null;
+  }
+  const parsed = Date.parse(rawTimestamp);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+function selectLatestPrereleaseRelease(releases) {
+  const prereleases = releases.filter((release) => release.prerelease && release.tag_name);
+  if (prereleases.length === 0) {
+    return null;
+  }
+  let selected = prereleases[0];
+  let selectedTimestamp = parseReleaseTimestamp(selected);
+  for (const release of prereleases.slice(1)) {
+    const timestamp = parseReleaseTimestamp(release);
+    if (timestamp === null) {
+      continue;
+    }
+    if (selectedTimestamp === null || timestamp > selectedTimestamp) {
+      selected = release;
+      selectedTimestamp = timestamp;
+    }
+  }
+  return selected;
+}
+function evaluateUpdateStatus(currentVersion, latestVersion, channel) {
+  if (channel === "alpha") {
+    const isUpToDate = currentVersion === latestVersion;
+    return { isUpToDate, updateAvailable: !isUpToDate };
+  }
+  const comparison = compareVersions(currentVersion, latestVersion);
+  return {
+    isUpToDate: comparison >= 0,
+    updateAvailable: comparison < 0
+  };
+}
+async function readCache(channel) {
+  try {
+    const cacheFile = getCacheFile(channel);
+    if (await _fsextra2.default.pathExists(cacheFile)) {
+      const data = await _fsextra2.default.readJson(cacheFile);
+      return data;
+    }
+  } catch (e) {
+  }
+  return null;
+}
+async function writeCache(channel, cache) {
+  try {
+    const cacheFile = getCacheFile(channel);
+    await _fsextra2.default.ensureDir(_path2.default.dirname(cacheFile));
+    await _fsextra2.default.writeJson(cacheFile, cache, { spaces: 2 });
+  } catch (e2) {
+  }
+}
+function isCacheValid(cache, intervalHours) {
+  try {
+    const lastCheck = new Date(cache.lastCheck);
+    const now = /* @__PURE__ */ new Date();
+    const hoursSinceCheck = (now.getTime() - lastCheck.getTime()) / (1e3 * 60 * 60);
+    return hoursSinceCheck < intervalHours;
+  } catch (e3) {
+    return false;
+  }
+}
+async function fetchLatestStableRelease() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    const response = await fetch(GITHUB_API_LATEST_URL, {
+      headers: {
+        "Accept": "application/vnd.github.v3+json",
+        "User-Agent": "autohand-cli"
+      },
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    if (data.tag_name) {
+      return {
+        version: data.tag_name.replace(/^v/, ""),
+        url: data.html_url || `https://github.com/${GITHUB_REPO}/releases/tag/${data.tag_name}`
+      };
+    }
+  } catch (e4) {
+  }
+  return null;
+}
+async function fetchLatestAlphaRelease() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    const response = await fetch(GITHUB_API_RELEASES_URL, {
+      headers: {
+        "Accept": "application/vnd.github.v3+json",
+        "User-Agent": "autohand-cli"
+      },
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (!response.ok) {
+      return null;
+    }
+    const releases = await response.json();
+    const latestPrerelease = selectLatestPrereleaseRelease(releases);
+    if (_optionalChain([latestPrerelease, 'optionalAccess', _ => _.tag_name])) {
+      return {
+        version: latestPrerelease.tag_name.replace(/^v/, ""),
+        url: latestPrerelease.html_url || `https://github.com/${GITHUB_REPO}/releases/tag/${latestPrerelease.tag_name}`
+      };
+    }
+  } catch (e5) {
+  }
+  return null;
+}
+function getInstallHint(channel) {
+  if (channel === "alpha") {
+    return "curl -fsSL https://autohand.ai/install.sh | sh -s -- --alpha";
+  }
+  return "curl -fsSL https://autohand.ai/install.sh | sh";
+}
+async function checkForUpdates(currentVersion, options = {}) {
+  const {
+    checkIntervalHours = DEFAULT_CHECK_INTERVAL_HOURS,
+    forceCheck = false
+  } = options;
+  const channel = detectChannel(currentVersion);
+  const result = {
+    currentVersion,
+    latestVersion: null,
+    isUpToDate: true,
+    updateAvailable: false,
+    channel
+  };
+  if (process.env.AUTOHAND_SKIP_UPDATE_CHECK === "1") {
+    return result;
+  }
+  try {
+    if (!forceCheck) {
+      const cache = await readCache(channel);
+      if (cache && isCacheValid(cache, checkIntervalHours)) {
+        result.latestVersion = cache.latestVersion;
+        result.releaseUrl = cache.releaseUrl;
+        const status = evaluateUpdateStatus(currentVersion, cache.latestVersion, channel);
+        result.isUpToDate = status.isUpToDate;
+        result.updateAvailable = status.updateAvailable;
+        return result;
+      }
+    }
+    const latest = channel === "alpha" ? await fetchLatestAlphaRelease() : await fetchLatestStableRelease();
+    if (latest) {
+      result.latestVersion = latest.version;
+      result.releaseUrl = latest.url;
+      const status = evaluateUpdateStatus(currentVersion, latest.version, channel);
+      result.isUpToDate = status.isUpToDate;
+      result.updateAvailable = status.updateAvailable;
+      await writeCache(channel, {
+        lastCheck: (/* @__PURE__ */ new Date()).toISOString(),
+        latestVersion: latest.version,
+        releaseUrl: latest.url
+      });
+    }
+  } catch (error) {
+    result.error = error instanceof Error ? error.message : "Unknown error";
+  }
+  return result;
+}
+
+
+
+
+exports.getInstallHint = getInstallHint; exports.checkForUpdates = checkForUpdates;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */