autohand-cli 0.8.2 → 0.9.0

package/dist/{chunk-FKSDEWDH.js → chunk-SWCQM52V.js}

@@ -1,16 +1,16 @@
-import {
-  package_default
-} from "./chunk-T73IDKDF.js";
 import {
   safePrompt
-} from "./chunk-6ZCULLCA.js";
+} from "./chunk-62RTC3XX.js";
+import {
+  package_default
+} from "./chunk-3PXKRVCW.js";
 import {
   AUTOHAND_FILES,
   AUTOHAND_PATHS
-} from "./chunk-EGFT4PGW.js";
+} from "./chunk-TWQDAUZU.js";
 import {
   t
-} from "./chunk-APIXPPMT.js";
+} from "./chunk-CBFH2J3O.js";
 
 // src/commands/feedback.ts
 import fs from "fs-extra";
@@ -74,12 +74,12 @@ async function feedback(_ctx) {
       name: "rating",
       message: "How would you rate your experience?",
       choices: [
-        { name: "5", message: "5 - Excellent" },
-        { name: "4", message: "4 - Good" },
-        { name: "3", message: "3 - Okay" },
-        { name: "2", message: "2 - Poor" },
-        { name: "1", message: "1 - Very Poor" },
-        { name: "skip", message: "s - Skip rating" }
+        { name: "5", message: "Excellent" },
+        { name: "4", message: "Good" },
+        { name: "3", message: "Okay" },
+        { name: "2", message: "Poor" },
+        { name: "1", message: "Very Poor" },
+        { name: "skip", message: "Skip rating" }
       ]
     }
   ]);
@@ -87,24 +87,65 @@ async function feedback(_ctx) {
     console.log(chalk.gray("Feedback discarded."));
     return null;
   }
-  const textAnswer = await safePrompt([
-    {
-      type: "input",
-      name: "feedback",
-      message: "What worked? What broke? (optional)"
-    }
-  ]);
-  if (!textAnswer) {
-    console.log(chalk.gray("Feedback discarded."));
+  if (ratingAnswer.rating === "skip") {
+    console.log(chalk.gray("Feedback skipped."));
     return null;
   }
-  const npsScore = ratingAnswer.rating === "skip" ? 0 : parseInt(ratingAnswer.rating, 10);
-  const freeformFeedback = textAnswer.feedback?.trim() || void 0;
+  const npsScore = parseInt(ratingAnswer.rating, 10);
+  let reason;
+  let improvement;
+  let recommend;
+  if (npsScore >= 4) {
+    const reasonAnswer = await safePrompt([
+      {
+        type: "input",
+        name: "reason",
+        message: "What do you like most about Autohand? (optional, press Enter to skip)"
+      }
+    ]);
+    if (!reasonAnswer) {
+      console.log(chalk.gray("Feedback discarded."));
+      return null;
+    }
+    reason = reasonAnswer.reason?.trim() || void 0;
+    const recommendAnswer = await safePrompt([
+      {
+        type: "select",
+        name: "recommend",
+        message: "Would you recommend Autohand to a colleague?",
+        choices: [
+          { name: "yes", message: "Yes" },
+          { name: "no", message: "No" }
+        ]
+      }
+    ]);
+    if (!recommendAnswer) {
+      console.log(chalk.gray("Feedback discarded."));
+      return null;
+    }
+    recommend = recommendAnswer.recommend === "yes";
+  } else {
+    const improvementAnswer = await safePrompt([
+      {
+        type: "input",
+        name: "improvement",
+        message: "What could we do better? (optional, press Enter to skip)"
+      }
+    ]);
+    if (!improvementAnswer) {
+      console.log(chalk.gray("Feedback discarded."));
+      return null;
+    }
+    improvement = improvementAnswer.improvement?.trim() || void 0;
+  }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const runtimeError = getLastRuntimeError();
   const deviceId = await getDeviceId();
   const payload = {
     npsScore,
+    recommend,
+    reason,
+    improvement,
     triggerType: "manual",
     timestamp: now,
     deviceId,
@@ -112,7 +153,6 @@ async function feedback(_ctx) {
     platform: process.platform,
     osVersion: os.release(),
     nodeVersion: process.version,
-    freeformFeedback,
     env: {
       platform: `${process.platform}-${process.arch}`,
       node: process.version,
@@ -153,7 +193,7 @@ async function sendFeedbackToApi(payload, apiBaseUrl) {
   const controller = new AbortController();
   const timeoutId = setTimeout(() => controller.abort(), API_TIMEOUT);
   try {
-    const response = await fetch(`${apiBaseUrl}/v1/feedback`, {
+    const response = await fetch(getFeedbackSubmitUrl(apiBaseUrl), {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -181,6 +221,9 @@ async function sendFeedbackToApi(payload, apiBaseUrl) {
 function getFeedbackApiBaseUrl(ctx) {
   return process.env.AUTOHAND_API_URL?.trim() || ctx.config?.api?.baseUrl?.trim() || DEFAULT_API_BASE_URL;
 }
+function getFeedbackSubmitUrl(apiBaseUrl) {
+  return `${apiBaseUrl.replace(/\/+$/, "")}/v1/feedback`;
+}
 function formatFeedbackApiError(status, rawBody) {
   const body = (rawBody ?? "").replace(/\s+/g, " ").trim();
   if (!body) {

package/dist/{chunk-H5SWOLG6.js → chunk-TBOLJDUG.js}

@@ -1,22 +1,22 @@
 import {
   DEFAULT_SYNC_CONFIG,
   createSyncService
-} from "./chunk-3PDTTAKJ.js";
-import {
-  getAuthClient
-} from "./chunk-HQ7YZKXE.js";
+} from "./chunk-2QL6MNXG.js";
 import {
   safePrompt
-} from "./chunk-6ZCULLCA.js";
+} from "./chunk-62RTC3XX.js";
+import {
+  getAuthClient
+} from "./chunk-IAGCRVJ3.js";
 import {
   saveConfig
-} from "./chunk-P47WPOXN.js";
+} from "./chunk-3UT7R3XV.js";
 import {
   AUTH_CONFIG
-} from "./chunk-EGFT4PGW.js";
+} from "./chunk-TWQDAUZU.js";
 import {
   t
-} from "./chunk-APIXPPMT.js";
+} from "./chunk-CBFH2J3O.js";
 
 // src/commands/login.ts
 import chalk from "chalk";
@@ -27,26 +27,39 @@ var metadata = {
 };
 async function openBrowser(url) {
   try {
-    const open = await import("open").then((m) => m.default).catch(() => null);
-    if (open) {
-      await open(url);
-      return true;
-    }
-    const { exec } = await import("child_process");
+    const { exec, execFile } = await import("child_process");
     const { promisify } = await import("util");
     const execAsync = promisify(exec);
+    const execFileAsync = promisify(execFile);
     const platform = process.platform;
-    let command;
     if (platform === "darwin") {
-      command = `open "${url}"`;
-    } else if (platform === "win32") {
-      command = `start "" "${url}"`;
-    } else {
-      command = `xdg-open "${url}"`;
+      await execFileAsync("open", [url]);
+      return true;
     }
-    await execAsync(command);
-    return true;
+    if (platform === "win32") {
+      await execAsync(`start "" "${url}"`);
+      return true;
+    }
+    const openers = ["xdg-open", "sensible-browser", "x-www-browser", "firefox", "chromium", "google-chrome"];
+    for (const opener of openers) {
+      try {
+        await execAsync(`command -v ${opener}`);
+        await execFileAsync(opener, [url]);
+        return true;
+      } catch {
+        continue;
+      }
+    }
+    console.log(`
+Please open this URL manually:
+${url}
+`);
+    return false;
   } catch {
+    console.log(`
+Please open this URL manually:
+${url}
+`);
     return false;
   }
 }
@@ -117,7 +130,9 @@ async function login(ctx) {
       console.log();
       console.log(chalk.green(t("commands.login.success", { email: pollResult.user.name || pollResult.user.email })));
       console.log();
-      await checkAndRestoreSyncData(pollResult.token, pollResult.user.id, updatedConfig);
+      if (process.stdin.isTTY && process.stdout.isTTY) {
+        await checkAndRestoreSyncData(pollResult.token, pollResult.user.id, updatedConfig);
+      }
       return null;
     }
     if (pollResult.status === "expired") {
@@ -141,7 +156,7 @@ async function checkAndRestoreSyncData(token, userId, config) {
         enabled: true
       }
     });
-    const { getSyncApiClient } = await import("./SyncApiClient-LVIO4C2S.js");
+    const { getSyncApiClient } = await import("./SyncApiClient-LRPFNCKJ.js");
     const apiClient = getSyncApiClient();
     const remoteManifest = await apiClient.getRemoteManifest(token);
     if (!remoteManifest || remoteManifest.files.length === 0) {

package/dist/chunk-TH26BQJG.js

@@ -0,0 +1,101 @@
+// src/actions/command.ts
+import { spawn } from "child_process";
+import { isAbsolute, join } from "path";
+function runCommand(cmd, args, cwd, options = {}) {
+  if (!cmd || typeof cmd !== "string") {
+    return Promise.reject(new Error("Command is required and must be a string"));
+  }
+  return new Promise((resolve, reject) => {
+    const workDir = options.directory ? isAbsolute(options.directory) ? options.directory : join(cwd, options.directory) : cwd;
+    const spawnOptions = {
+      cwd: workDir,
+      shell: options.shell ?? false,
+      env: {
+        ...process.env,
+        AUTOHAND_CLI: "1",
+        ...options.env
+      }
+    };
+    if (options.background) {
+      spawnOptions.detached = true;
+      spawnOptions.stdio = ["ignore", "pipe", "pipe"];
+    } else if (options.interactive) {
+      spawnOptions.stdio = "inherit";
+    }
+    let child;
+    try {
+      child = spawn(cmd, args, spawnOptions);
+    } catch (error) {
+      const err = error;
+      if (err.code === "ENOENT") {
+        reject(new Error(`Command not found: ${cmd}`));
+      } else {
+        reject(error);
+      }
+      return;
+    }
+    if (options.background) {
+      child.unref();
+      resolve({
+        stdout: "",
+        stderr: "",
+        code: null,
+        backgroundPid: child.pid,
+        signal: null
+      });
+      return;
+    }
+    if (options.interactive) {
+      child.once("error", (error) => {
+        if (error.code === "ENOENT") {
+          reject(new Error(`Command not found: ${cmd}`));
+        } else {
+          reject(error);
+        }
+      });
+      child.once("close", (code, signal) => {
+        resolve({ stdout: "", stderr: "", code, signal });
+      });
+      return;
+    }
+    let stdout = "";
+    let stderr = "";
+    let timeoutId;
+    if (options.timeout && options.timeout > 0) {
+      timeoutId = setTimeout(() => {
+        child.kill("SIGTERM");
+      }, options.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) => {
+      if (timeoutId) clearTimeout(timeoutId);
+      if (error.code === "ENOENT") {
+        reject(new Error(`Command not found: ${cmd}`));
+      } else {
+        reject(error);
+      }
+    });
+    child.once("close", (code, signal) => {
+      if (timeoutId) clearTimeout(timeoutId);
+      resolve({ stdout, stderr, code, signal });
+    });
+  });
+}
+
+export {
+  runCommand
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-245KJE5Y.cjs → chunk-TJNBASFD.cjs}

@@ -1,27 +1,35 @@
 "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 _chunkBVKXEQVGcjs = require('./chunk-BVKXEQVG.cjs');
+var _chunkMOJ7ADW4cjs = require('./chunk-MOJ7ADW4.cjs');
 
 
-var _chunk7BTSG4MEcjs = require('./chunk-7BTSG4ME.cjs');
+var _chunk46C73ZKKcjs = require('./chunk-46C73ZKK.cjs');
+
+
+var _chunkCHI52KFRcjs = require('./chunk-CHI52KFR.cjs');
 
 // src/commands/agents.ts
 var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
 var metadata = {
   command: "/agents",
-  description: _chunk7BTSG4MEcjs.t.call(void 0, "commands.agents.description"),
+  description: _chunkCHI52KFRcjs.t.call(void 0, "commands.agents.description"),
   implemented: true,
+  subcommands: [
+    { name: "new", description: "create a new sub-agent from a description" }
+  ],
   prd: "prd/sub_agents_architecture.md"
 };
 async function handler() {
-  const registry = _chunkBVKXEQVGcjs.AgentRegistry.getInstance();
+  const registry = _chunkMOJ7ADW4cjs.AgentRegistry.getInstance();
+  const config = await _chunk46C73ZKKcjs.loadConfig.call(void 0, void 0, process.cwd());
+  registry.configureExternalAgents(config.externalAgents);
   await registry.loadAgents();
   const agents = registry.getAllAgents();
   if (agents.length === 0) {
-    return `${_chunk7BTSG4MEcjs.t.call(void 0, "commands.agents.noAgents")}
+    return `${_chunkCHI52KFRcjs.t.call(void 0, "commands.agents.noAgents")}
 ${_chalk2.default.gray(`Path: ${_chalk2.default.cyan(registry.getAgentsDirectory())}`)}`;
   }
-  let output = _chalk2.default.bold(`${_chunk7BTSG4MEcjs.t.call(void 0, "commands.agents.title")}:
+  let output = _chalk2.default.bold(`${_chunkCHI52KFRcjs.t.call(void 0, "commands.agents.title")}:
 
 `);
   for (const agent of agents) {

package/dist/chunk-TKKN34TV.js

@@ -0,0 +1,229 @@
+import {
+  AutoReportManager
+} from "./chunk-JIMSII7R.js";
+import {
+  package_default
+} from "./chunk-3PXKRVCW.js";
+import {
+  loadConfig
+} from "./chunk-3UT7R3XV.js";
+
+// src/reporting/processErrorReporting.ts
+var DEFAULT_API_BASE_URL = "https://api.autohand.ai";
+var DEFAULT_REPORT_TIMEOUT_MS = 6500;
+var installedProcesses = /* @__PURE__ */ new WeakSet();
+var managerCache = /* @__PURE__ */ new Map();
+function getArgValue(argv, flag) {
+  if (!argv) {
+    return void 0;
+  }
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (token === flag) {
+      return argv[i + 1];
+    }
+    if (token.startsWith(`${flag}=`)) {
+      return token.slice(flag.length + 1);
+    }
+  }
+  return void 0;
+}
+function resolveConfigPath(processRef, explicitPath) {
+  return explicitPath ?? getArgValue(processRef.argv, "--config") ?? processRef.env.AUTOHAND_CONFIG;
+}
+function detectClientName(processRef) {
+  const envClientName = processRef.env.AUTOHAND_CLIENT_NAME;
+  if (envClientName) {
+    return envClientName;
+  }
+  const mode = getArgValue(processRef.argv, "--mode");
+  if (mode === "acp" || mode === "rpc") {
+    return mode;
+  }
+  return "cli";
+}
+function getLogPrefix(processRef) {
+  return detectClientName(processRef) === "acp" ? "[ACP]" : "[DEBUG]";
+}
+function captureLastError(reason) {
+  globalThis.__autohandLastError = reason;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function buildFallbackConfig(configPath, processRef) {
+  return {
+    provider: "openrouter",
+    api: {
+      baseUrl: processRef.env.AUTOHAND_API_URL || DEFAULT_API_BASE_URL,
+      companySecret: processRef.env.AUTOHAND_SECRET || ""
+    },
+    autoReport: {
+      enabled: true
+    },
+    telemetry: {
+      enabled: false
+    },
+    configPath: configPath ?? "process-error-fallback",
+    isNewConfig: false
+  };
+}
+async function getAutoReportManager(processRef, explicitConfigPath) {
+  const configPath = resolveConfigPath(processRef, explicitConfigPath);
+  const cacheKey = configPath ?? "__default__";
+  const cached = managerCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const managerPromise = (async () => {
+    let config;
+    try {
+      config = await loadConfig(configPath);
+    } catch {
+      config = buildFallbackConfig(configPath, processRef);
+    }
+    return new AutoReportManager(config, package_default.version);
+  })();
+  managerCache.set(cacheKey, managerPromise);
+  return managerPromise;
+}
+function isIgnorableStdinReadError(err, _processRef) {
+  if (!err || typeof err !== "object") {
+    return false;
+  }
+  const maybeError = err;
+  return maybeError.code === "EIO" && maybeError.syscall === "read";
+}
+function isIgnorableFilesystemError(err) {
+  if (!err || typeof err !== "object") return false;
+  const maybeError = err;
+  if (maybeError.syscall !== "mkdir") return false;
+  return maybeError.code === "EACCES" || maybeError.code === "EEXIST";
+}
+function isIgnorableTerminalOrRuntimeError(err) {
+  if (!err || typeof err !== "object") return false;
+  const message = err.message ?? "";
+  if (/setRawMode.*errno/i.test(message)) return true;
+  if (message === "Generator is executing") return true;
+  if (message.includes("node:sqlite")) return true;
+  return false;
+}
+function isIgnorableUnhandledRejection(reason, processRef) {
+  if (reason && typeof reason === "object" && reason.code === "ERR_USE_AFTER_CLOSE") {
+    return true;
+  }
+  if (isIgnorableStdinReadError(reason, processRef)) return true;
+  if (isIgnorableFilesystemError(reason)) return true;
+  if (isIgnorableTerminalOrRuntimeError(reason)) return true;
+  return false;
+}
+function toReportableError(reason) {
+  if (reason instanceof Error) {
+    return reason;
+  }
+  const fallbackName = "NonErrorProcessFault";
+  if (reason && typeof reason === "object") {
+    const maybeErrorLike = reason;
+    const message = typeof maybeErrorLike.message === "string" ? maybeErrorLike.message : safeSerialize(reason);
+    const error2 = new Error(message);
+    error2.name = typeof maybeErrorLike.name === "string" ? maybeErrorLike.name : fallbackName;
+    return error2;
+  }
+  const error = new Error(typeof reason === "string" ? reason : String(reason));
+  error.name = fallbackName;
+  return error;
+}
+function safeSerialize(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function describeReasonType(reason) {
+  if (reason === null) {
+    return "null";
+  }
+  if (Array.isArray(reason)) {
+    return "array";
+  }
+  return typeof reason;
+}
+async function reportProcessError(reason, options) {
+  const processRef = options.processRef ?? process;
+  if (options.handler === "unhandledRejection" && isIgnorableUnhandledRejection(reason, processRef)) {
+    return;
+  }
+  if (options.handler === "uncaughtException" && (isIgnorableStdinReadError(reason, processRef) || isIgnorableTerminalOrRuntimeError(reason))) {
+    return;
+  }
+  captureLastError(reason);
+  const error = toReportableError(reason);
+  const manager = await getAutoReportManager(processRef, options.configPath);
+  const reportPromise = manager.reportError(error, {
+    context: {
+      source: "process",
+      handler: options.handler,
+      clientName: detectClientName(processRef),
+      fatal: options.handler === "uncaughtException",
+      rawType: describeReasonType(reason),
+      ...options.extraContext ?? {}
+    }
+  });
+  await Promise.race([
+    reportPromise,
+    sleep(options.reportTimeoutMs ?? DEFAULT_REPORT_TIMEOUT_MS)
+  ]);
+}
+function installProcessErrorHandlers(options = {}) {
+  const processRef = options.processRef ?? process;
+  if (installedProcesses.has(processRef)) {
+    return;
+  }
+  installedProcesses.add(processRef);
+  const logError = options.logError ?? console.error.bind(console);
+  const exit = options.exit ?? ((code) => {
+    processRef.exit(code);
+  });
+  processRef.on("uncaughtException", (error) => {
+    if (isIgnorableStdinReadError(error, processRef)) {
+      return;
+    }
+    if (isIgnorableTerminalOrRuntimeError(error)) {
+      return;
+    }
+    captureLastError(error);
+    logError(`${getLogPrefix(processRef)} Uncaught Exception:`, error);
+    void (async () => {
+      await reportProcessError(error, {
+        handler: "uncaughtException",
+        processRef,
+        configPath: options.configPath,
+        reportTimeoutMs: options.reportTimeoutMs
+      });
+      exit(1);
+    })();
+  });
+  processRef.on("unhandledRejection", (reason, promise) => {
+    if (isIgnorableUnhandledRejection(reason, processRef)) {
+      return;
+    }
+    captureLastError(reason);
+    logError(`${getLogPrefix(processRef)} Unhandled Rejection at:`, promise, "reason:", reason);
+    void reportProcessError(reason, {
+      handler: "unhandledRejection",
+      processRef,
+      configPath: options.configPath,
+      reportTimeoutMs: options.reportTimeoutMs
+    });
+  });
+}
+
+export {
+  installProcessErrorHandlers
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-TQ33WBY5.cjs

@@ -0,0 +1,74 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/ui/displayUtils.ts
+var ANSI_PATTERN = /\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)|\u001b\[[0-?]*[ -/]*[@-~]/g;
+function stripAnsiCodes(value) {
+  return value.replace(ANSI_PATTERN, "");
+}
+function enableBracketedPaste(output) {
+  try {
+    output.write("\x1B[?2004h");
+  } catch (error) {
+    if (process.env.DEBUG_PASTE) {
+      output.write(`[DEBUG] Failed to enable bracketed paste: ${error}
+`);
+    }
+  }
+}
+function disableBracketedPaste(output) {
+  try {
+    output.write("\x1B[?2004l");
+  } catch (e) {
+  }
+}
+function shuffleInPlace(arr) {
+  for (let i = arr.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [arr[i], arr[j]] = [arr[j], arr[i]];
+  }
+}
+var PASTE_LINE_THRESHOLD = 5;
+var PASTE_CHAR_THRESHOLD = 1500;
+function getContentDisplay(text) {
+  const charCount = Array.from(text).length;
+  if (!text) {
+    return {
+      visual: "",
+      actual: "",
+      isPasted: false,
+      lineCount: 1,
+      charCount
+    };
+  }
+  const lines = text.split("\n");
+  const lineCount = lines.length;
+  if (lineCount >= PASTE_LINE_THRESHOLD || charCount >= PASTE_CHAR_THRESHOLD) {
+    return {
+      visual: `[Text pasted ${charCount} chars]`,
+      actual: text,
+      isPasted: true,
+      lineCount,
+      charCount
+    };
+  }
+  return {
+    visual: text,
+    actual: text,
+    isPasted: false,
+    lineCount,
+    charCount
+  };
+}
+
+
+
+
+
+
+
+exports.stripAnsiCodes = stripAnsiCodes; exports.enableBracketedPaste = enableBracketedPaste; exports.disableBracketedPaste = disableBracketedPaste; exports.shuffleInPlace = shuffleInPlace; exports.getContentDisplay = getContentDisplay;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Display utilities for smart content rendering
+ */