autohand-cli 0.9.0 → 0.9.1

package/dist/chunk-26G7YGOW.js

@@ -0,0 +1,367 @@
+import {
+  package_default
+} from "./chunk-JB3JCYBJ.js";
+import {
+  showModal
+} from "./chunk-NZ3ZWLUW.js";
+import {
+  saveConfig
+} from "./chunk-IEPLQ47J.js";
+import {
+  formatFeatureList,
+  formatFeatureStatus,
+  getFeatureState,
+  isLocalFeatureId,
+  listFeatureStates,
+  setFeatureState
+} from "./chunk-LANGD5CO.js";
+import {
+  AUTOHAND_FILES
+} from "./chunk-SHRLFX6F.js";
+
+// src/features/RemoteFeatureFlagManager.ts
+import crypto from "crypto";
+import os from "os";
+import path from "path";
+import fs from "fs-extra";
+var FEATURE_FLAG_REQUEST_TIMEOUT_MS = 1500;
+function getApiBaseUrl(config) {
+  return (config.api?.baseUrl || config.telemetry?.apiBaseUrl || "https://api.autohand.ai").replace(/\/+$/, "");
+}
+function readDeviceId() {
+  try {
+    fs.ensureDirSync(path.dirname(AUTOHAND_FILES.deviceId));
+    if (fs.existsSync(AUTOHAND_FILES.deviceId)) {
+      const existing = fs.readFileSync(AUTOHAND_FILES.deviceId, "utf8").trim();
+      if (existing) return existing;
+    }
+    const next = crypto.randomUUID();
+    fs.writeFileSync(AUTOHAND_FILES.deviceId, next);
+    return next;
+  } catch {
+    return crypto.randomUUID();
+  }
+}
+function parseSnapshot(value) {
+  if (value.success !== true || !Array.isArray(value.flags)) return null;
+  const flags = [];
+  for (const flag of value.flags) {
+    if (!flag || typeof flag !== "object") continue;
+    const candidate = flag;
+    if (typeof candidate.key !== "string" || typeof candidate.enabled !== "boolean") continue;
+    flags.push({
+      key: candidate.key,
+      enabled: candidate.enabled,
+      reason: typeof candidate.reason === "string" ? candidate.reason : "unknown",
+      userOverridable: candidate.userOverridable !== false
+    });
+  }
+  return {
+    success: true,
+    environment: typeof value.environment === "string" ? value.environment : "production",
+    flags,
+    evaluatedAt: typeof value.evaluatedAt === "string" ? value.evaluatedAt : (/* @__PURE__ */ new Date()).toISOString(),
+    ttlSeconds: typeof value.ttlSeconds === "number" ? value.ttlSeconds : 300
+  };
+}
+function isSnapshotFresh(snapshot) {
+  const evaluatedAt = Date.parse(snapshot.evaluatedAt);
+  if (Number.isNaN(evaluatedAt)) return false;
+  const ttlMs = Math.max(0, snapshot.ttlSeconds) * 1e3;
+  return Date.now() - evaluatedAt < ttlMs;
+}
+function createEvaluationUrl(config, deviceId, clientVersion) {
+  const environment = config.features?.environment || "production";
+  const url = new URL(`${getApiBaseUrl(config)}/v1/feature-flags/evaluate`);
+  url.searchParams.set("environment", environment);
+  url.searchParams.set("clientType", "cli");
+  url.searchParams.set("deviceId", deviceId);
+  url.searchParams.set("cliVersion", clientVersion);
+  url.searchParams.set("platform", process.platform);
+  return url;
+}
+async function downloadRemoteFeatureFlags(config, deviceId, clientVersion) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FEATURE_FLAG_REQUEST_TIMEOUT_MS);
+  try {
+    const response = await fetch(createEvaluationUrl(config, deviceId, clientVersion), { signal: controller.signal });
+    if (!response.ok) return null;
+    return parseSnapshot(await response.json());
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function writeRemoteFeatureFlagCache(snapshot) {
+  await fs.ensureDir(path.dirname(AUTOHAND_FILES.featureFlagsCache));
+  await fs.writeJson(AUTOHAND_FILES.featureFlagsCache, snapshot, { spaces: 2 });
+}
+async function loadCachedRemoteFeatureFlags() {
+  try {
+    if (!await fs.pathExists(AUTOHAND_FILES.featureFlagsCache)) {
+      return null;
+    }
+    const data = await fs.readJson(AUTOHAND_FILES.featureFlagsCache);
+    return parseSnapshot(data);
+  } catch {
+    return null;
+  }
+}
+async function loadRemoteFeatureFlags(config, options = {}) {
+  const cached = await loadCachedRemoteFeatureFlags();
+  if (!options.forceRefresh && cached && isSnapshotFresh(cached)) {
+    return cached;
+  }
+  const downloaded = await downloadRemoteFeatureFlags(config, readDeviceId(), package_default.version);
+  if (downloaded) {
+    await writeRemoteFeatureFlagCache(downloaded);
+    return downloaded;
+  }
+  return options.allowCachedFallback === false ? null : cached;
+}
+var RemoteFeatureFlagManager = class {
+  constructor(config) {
+    this.config = config;
+    this.apiBaseUrl = getApiBaseUrl(config);
+    this.environment = config.features?.environment || "production";
+    this.clientVersion = package_default.version;
+  }
+  config;
+  snapshot = null;
+  deviceId = readDeviceId();
+  apiBaseUrl;
+  environment;
+  clientVersion;
+  async refreshFeatureFlags() {
+    const downloaded = await downloadRemoteFeatureFlags(this.config, this.deviceId, this.clientVersion);
+    if (downloaded) {
+      this.snapshot = downloaded;
+      await writeRemoteFeatureFlagCache(downloaded);
+      return;
+    }
+    this.snapshot = await loadCachedRemoteFeatureFlags();
+  }
+  getSnapshot() {
+    return this.snapshot;
+  }
+  isFeatureEnabled(key, localDefault = false) {
+    if (isLocalFeatureId(key)) {
+      return localDefault;
+    }
+    const flag = this.snapshot?.flags.find((item) => item.key === key);
+    if (!flag) return localDefault;
+    if (!flag.enabled) return false;
+    return this.config.features?.remoteOverrides?.[key] !== "off";
+  }
+  async trackFeatureActivation(key, metadata2) {
+    void metadata2;
+    const flag = this.snapshot?.flags.find((item) => item.key === key);
+    if (!flag || !this.isFeatureEnabled(key)) return;
+    try {
+      await fetch(`${this.apiBaseUrl}/v1/feature-flags/events`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          events: [{
+            key,
+            environment: this.environment,
+            eventType: "activation",
+            enabled: true,
+            reason: flag.reason,
+            deviceId: this.deviceId,
+            clientType: "cli",
+            cliVersion: this.clientVersion,
+            platform: process.platform,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }]
+        })
+      });
+    } catch {
+    }
+  }
+  getStatus() {
+    return {
+      apiBaseUrl: this.apiBaseUrl,
+      environment: this.environment,
+      deviceId: this.deviceId,
+      platform: process.platform,
+      osVersion: os.release(),
+      evaluatedAt: this.snapshot?.evaluatedAt || null
+    };
+  }
+};
+
+// src/commands/features.ts
+function renderUsage() {
+  return [
+    "Usage: /features [list|status|enable|disable|refresh]",
+    "",
+    "Commands:",
+    "  /features",
+    "  /features list",
+    "  /features status <feature>",
+    "  /features enable <feature>",
+    "  /features disable <feature>",
+    "  /features refresh"
+  ].join("\n");
+}
+function requireConfig(config) {
+  return config ?? "Config not available.";
+}
+async function setFeatureEnabled(config, featureId, enabled, remoteSnapshot) {
+  if (!featureId) {
+    return renderUsage();
+  }
+  const snapshot = remoteSnapshot === void 0 ? await loadRemoteFeatureFlags(config) : remoteSnapshot;
+  const result = setFeatureState(config, featureId, enabled, { remoteSnapshot: snapshot });
+  if (!result.ok || !result.feature) {
+    return result.error ?? `Unknown feature "${featureId}".`;
+  }
+  await saveConfig(config);
+  if (result.feature.source === "remote") {
+    if (enabled) {
+      return `Following remote state for ${result.feature.id} (currently ${result.feature.enabled ? "on" : "off"}).`;
+    }
+    return `Disabled ${result.feature.id} locally. Remote state remains ${result.feature.remoteEnabled ? "on" : "off"}.`;
+  }
+  const action = enabled ? "Enabled" : "Disabled";
+  const restartNote = result.feature.requiresRestart ? " Restart Autohand for this to fully apply." : "";
+  return `${action} ${result.feature.id}.${restartNote}`;
+}
+async function showInteractiveFeatures(config, remoteSnapshot) {
+  let toggleCount = 0;
+  const pendingSaves = [];
+  const states = listFeatureStates(config, { remoteSnapshot });
+  const initialStates = new Map(states.map((feature) => [feature.id, feature.enabled]));
+  const finalStates = new Map(initialStates);
+  const restartRequired = new Set(states.filter((feature) => feature.requiresRestart).map((feature) => feature.id));
+  const options = states.map((feature) => ({
+    label: `${feature.id.padEnd(26)} ${feature.source.padEnd(8)} ${feature.stage.padEnd(12)} ${feature.enabled ? "on" : "off"}`,
+    value: feature.id,
+    checked: feature.enabled,
+    description: feature.description
+  }));
+  await showModal({
+    title: "Features - space toggles, enter closes",
+    options,
+    multiSelect: true,
+    maxVisible: 12,
+    onToggle: (option, checked) => {
+      const result = setFeatureState(config, option.value, checked, { remoteSnapshot });
+      if (!result.ok) {
+        return;
+      }
+      toggleCount += 1;
+      finalStates.set(option.value, result.feature?.enabled ?? checked);
+      pendingSaves.push(saveConfig(config));
+    }
+  });
+  await Promise.all(pendingSaves);
+  if (toggleCount === 0) {
+    return null;
+  }
+  const enabled = [];
+  const disabled = [];
+  for (const [featureId, initiallyEnabled] of initialStates) {
+    const finallyEnabled = finalStates.get(featureId);
+    if (finallyEnabled === initiallyEnabled || typeof finallyEnabled !== "boolean") {
+      continue;
+    }
+    if (finallyEnabled) {
+      enabled.push(featureId);
+    } else {
+      disabled.push(featureId);
+    }
+  }
+  return formatInteractiveFeatureSummary({
+    enabled,
+    disabled,
+    restartRequired: [...new Set([...enabled, ...disabled].filter((featureId) => restartRequired.has(featureId)))]
+  });
+}
+function formatChangedFeatures(action, featureIds) {
+  if (featureIds.length === 0) {
+    return null;
+  }
+  if (featureIds.length === 1) {
+    return `${action} ${featureIds[0]}.`;
+  }
+  return `${action} ${featureIds.length} features: ${featureIds.join(", ")}.`;
+}
+function formatInteractiveFeatureSummary(changes) {
+  const parts = [
+    formatChangedFeatures("Enabled", changes.enabled),
+    formatChangedFeatures("Disabled", changes.disabled)
+  ].filter((part) => Boolean(part));
+  if (changes.restartRequired.length > 0) {
+    parts.push(`Restart required for: ${changes.restartRequired.join(", ")}.`);
+  }
+  return parts.length > 0 ? parts.join(" ") : null;
+}
+async function features(ctx, args = []) {
+  const required = requireConfig(ctx.config);
+  if (typeof required === "string") {
+    return required;
+  }
+  const subcommand = (args[0] ?? "").toLowerCase();
+  const featureId = args[1];
+  const forceRefresh = subcommand === "refresh";
+  const remoteSnapshot = await loadRemoteFeatureFlags(required, {
+    forceRefresh,
+    allowCachedFallback: !forceRefresh
+  });
+  switch (subcommand) {
+    case "":
+      return showInteractiveFeatures(required, remoteSnapshot);
+    case "list":
+    case "ls":
+      if (ctx.interactive) {
+        return showInteractiveFeatures(required, remoteSnapshot);
+      }
+      return formatFeatureList(required, { remoteSnapshot });
+    case "status":
+    case "show":
+      return featureId ? formatFeatureStatus(required, featureId, { remoteSnapshot }) : renderUsage();
+    case "enable":
+    case "on":
+      return setFeatureEnabled(required, featureId, true, remoteSnapshot);
+    case "disable":
+    case "off":
+      return setFeatureEnabled(required, featureId, false, remoteSnapshot);
+    case "refresh":
+      if (!remoteSnapshot) {
+        return "No remote feature flags available. Using local feature switches only.";
+      }
+      return `Downloaded ${remoteSnapshot.flags.length} remote feature${remoteSnapshot.flags.length === 1 ? "" : "s"} from ${remoteSnapshot.environment}.`;
+    default:
+      if (getFeatureState(required, subcommand, { remoteSnapshot })) {
+        return formatFeatureStatus(required, subcommand, { remoteSnapshot });
+      }
+      return renderUsage();
+  }
+}
+var metadata = {
+  command: "/features",
+  description: "list and toggle Autohand feature switches",
+  implemented: true,
+  subcommands: [
+    { name: "list", description: "List feature switches and current state" },
+    { name: "status", description: "Show one feature switch" },
+    { name: "enable", description: "Enable a feature switch" },
+    { name: "disable", description: "Disable a feature switch" },
+    { name: "refresh", description: "Download remote feature flags from the Autohand API" }
+  ]
+};
+
+export {
+  RemoteFeatureFlagManager,
+  setFeatureEnabled,
+  features,
+  metadata
+};
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-75EDROHL.cjs → chunk-2ESQR35E.cjs}

@@ -2,10 +2,10 @@
 
 
 
-var _chunkCH2J4PVEcjs = require('./chunk-CH2J4PVE.cjs');
+var _chunkCK4HAHVYcjs = require('./chunk-CK4HAHVY.cjs');
 
 
-var _chunkCHI52KFRcjs = require('./chunk-CHI52KFR.cjs');
+var _chunkSY2P3Z5Wcjs = require('./chunk-SY2P3Z5W.cjs');
 
 // src/commands/export.ts
 var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
@@ -245,7 +245,7 @@ function getSuggestedFilename(metadata2, format) {
 // src/commands/export.ts
 var metadata = {
   command: "/export",
-  description: _chunkCHI52KFRcjs.t.call(void 0, "commands.export.description"),
+  description: _chunkSY2P3Z5Wcjs.t.call(void 0, "commands.export.description"),
   implemented: true
 };
 async function execute(args, context) {
@@ -265,7 +265,7 @@ async function execute(args, context) {
       label: `${s.projectName} - ${new Date(s.createdAt).toLocaleString()} (${s.messageCount} messages)`,
       value: s.sessionId
     }));
-    const sessionResult = await _chunkCH2J4PVEcjs.showModal.call(void 0, {
+    const sessionResult = await _chunkCK4HAHVYcjs.showModal.call(void 0, {
       title: "Select a session to export:",
       options: sessionOptions
     });
@@ -286,7 +286,7 @@ async function execute(args, context) {
     { label: "JSON (.json)", value: "json" },
     { label: "HTML (.html)", value: "html" }
   ];
-  const formatResult = await _chunkCH2J4PVEcjs.showModal.call(void 0, {
+  const formatResult = await _chunkCK4HAHVYcjs.showModal.call(void 0, {
     title: "Export format:",
     options: formatOptions
   });
@@ -297,17 +297,17 @@ async function execute(args, context) {
   const format = formatResult.value;
   const options = {};
   if (format === "md" || format === "html") {
-    options.includeToolOutputs = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+    options.includeToolOutputs = await _chunkCK4HAHVYcjs.showConfirm.call(void 0, {
       title: "Include tool outputs?",
       defaultValue: true
     });
-    options.includeToc = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+    options.includeToc = await _chunkCK4HAHVYcjs.showConfirm.call(void 0, {
       title: "Include table of contents?",
       defaultValue: false
     });
   }
   const suggestedFilename = getSuggestedFilename(metadata2, format);
-  const filename = await _chunkCH2J4PVEcjs.showInput.call(void 0, {
+  const filename = await _chunkCK4HAHVYcjs.showInput.call(void 0, {
     title: "Save as:",
     defaultValue: suggestedFilename
   });
@@ -331,11 +331,11 @@ async function execute(args, context) {
   try {
     await saveExport(content, filePath);
     console.log();
-    console.log(_chalk2.default.green(_chunkCHI52KFRcjs.t.call(void 0, "commands.export.success", { path: filePath })));
+    console.log(_chalk2.default.green(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.export.success", { path: filePath })));
     console.log(_chalk2.default.gray(`  ${messages.length} messages, ${(Buffer.byteLength(content, "utf8") / 1024).toFixed(1)} KB`));
     console.log();
   } catch (error) {
-    console.log(_chalk2.default.red(_chunkCHI52KFRcjs.t.call(void 0, "commands.export.failed", { error: error.message })));
+    console.log(_chalk2.default.red(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.export.failed", { error: error.message })));
   }
 }
 

package/dist/{chunk-HKYZSUQ5.js → chunk-2IW5YFJ4.js}

@@ -4,21 +4,21 @@ import {
 import {
   I18nProvider,
   inkRenderOptions
-} from "./chunk-NMQ47RCG.js";
+} from "./chunk-HZWU6IO3.js";
 import {
   loadConfig,
   saveConfig
-} from "./chunk-3UT7R3XV.js";
+} from "./chunk-IEPLQ47J.js";
 import {
   ThemeProvider,
   useTheme
 } from "./chunk-NBGOIFKP.js";
 import {
   PROJECT_DIR_NAME
-} from "./chunk-TWQDAUZU.js";
+} from "./chunk-SHRLFX6F.js";
 import {
   t
-} from "./chunk-CBFH2J3O.js";
+} from "./chunk-LEZEWKPA.js";
 
 // src/commands/mcp.ts
 import chalk from "chalk";

package/dist/{chunk-JP3YHTQ2.cjs → chunk-3ICORF7M.cjs}

@@ -1,9 +1,9 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var _chunk7MU7LWF3cjs = require('./chunk-7MU7LWF3.cjs');
+var _chunkS5JNQIGLcjs = require('./chunk-S5JNQIGL.cjs');
 
 
-var _chunkE26KKI46cjs = require('./chunk-E26KKI46.cjs');
+var _chunkKASXKDF2cjs = require('./chunk-KASXKDF2.cjs');
 
 // src/commands/agents-new.ts
 var _path = require('path'); var _path2 = _interopRequireDefault(_path);
@@ -16,7 +16,7 @@ var metadata = {
   prd: "prd/sub_agents_architecture.md"
 };
 async function createAgent(ctx) {
-  const answers = await _chunk7MU7LWF3cjs.safePrompt.call(void 0, [
+  const answers = await _chunkS5JNQIGLcjs.safePrompt.call(void 0, [
     {
       type: "input",
       name: "name",
@@ -83,7 +83,7 @@ function buildPrompt(name, description) {
   ].filter(Boolean).join("\n");
 }
 function getAgentsDir() {
-  return _chunkE26KKI46cjs.AUTOHAND_PATHS.agents;
+  return _chunkKASXKDF2cjs.AUTOHAND_PATHS.agents;
 }
 function slugify(input) {
   return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "agent";

package/dist/{chunk-4256YRCO.cjs → chunk-3UC6DMFI.cjs}

@@ -1,15 +1,19 @@
 "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; }
 
+var _chunkNVATU4V6cjs = require('./chunk-NVATU4V6.cjs');
+
+
 var _chunkLJD7KR3Lcjs = require('./chunk-LJD7KR3L.cjs');
 
 
-var _chunkIKUMVBCWcjs = require('./chunk-IKUMVBCW.cjs');
 
+var _chunkSD3NTC7Dcjs = require('./chunk-SD3NTC7D.cjs');
 
-var _chunkREMGR23Vcjs = require('./chunk-REMGR23V.cjs');
 
+var _chunkAQ5PVHOCcjs = require('./chunk-AQ5PVHOC.cjs');
 
-var _chunkCHI52KFRcjs = require('./chunk-CHI52KFR.cjs');
+
+var _chunkSY2P3Z5Wcjs = require('./chunk-SY2P3Z5W.cjs');
 
 // src/commands/about.ts
 var _child_process = require('child_process');
@@ -20,9 +24,9 @@ function getCommitFromAlphaVersion(version) {
 }
 function getGitCommit() {
   if (true) {
-    return "8cc71ec";
+    return "da69f79";
   }
-  const alphaCommit = getCommitFromAlphaVersion(_chunkREMGR23Vcjs.package_default.version);
+  const alphaCommit = getCommitFromAlphaVersion(_chunkAQ5PVHOCcjs.package_default.version);
   if (alphaCommit) {
     return alphaCommit;
   }
@@ -34,33 +38,42 @@ function getGitCommit() {
 }
 function getVersionString() {
   const commit = getGitCommit();
-  return commit !== "unknown" ? `${_chunkREMGR23Vcjs.package_default.version} (${commit})` : _chunkREMGR23Vcjs.package_default.version;
+  return commit !== "unknown" ? `${_chunkAQ5PVHOCcjs.package_default.version} (${commit})` : _chunkAQ5PVHOCcjs.package_default.version;
 }
-async function about() {
+async function about(ctx = {}) {
   const theme = _chunkLJD7KR3Lcjs.createCommandTheme.call(void 0, );
+  const greetingName = _chunkNVATU4V6cjs.getUserGreetingName.call(void 0, ctx.config);
+  const terminalColumns = _nullishCoalesce(ctx.terminalColumns, () => ( _chunkSD3NTC7Dcjs.getTerminalColumns.call(void 0, process.stdout)));
   const lines = [
-    theme.muted(_chunkIKUMVBCWcjs.ASCII_FRIEND),
+    theme.muted(_chunkSD3NTC7Dcjs.renderAutohandLogo.call(void 0, { columns: terminalColumns })),
     "",
-    theme.accent(`${_chunkCHI52KFRcjs.t.call(void 0, "commands.about.title")} v${getVersionString()}`),
-    theme.muted(_chunkCHI52KFRcjs.t.call(void 0, "commands.about.subtitle")),
+    theme.accent(`${_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.about.title")} v${getVersionString()}`),
+    theme.muted(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.about.subtitle")),
     ""
   ];
+  if (greetingName) {
+    lines.push(theme.text(`Hey ${greetingName}, here are a few suggestions for what you could do next:`));
+    lines.push(theme.text(`   \u2022 Review model, context, and account usage: ${theme.accent("/usage")}`));
+    lines.push(theme.text(`   \u2022 Check current session and runtime status: ${theme.accent("/status")}`));
+    lines.push(theme.text(`   \u2022 Discover feature toggles available to you: ${theme.accent("/features")}`));
+    lines.push("");
+  }
   const websiteUrl = "https://autohand.ai";
   const githubUrl = "https://github.com/autohandai/";
   const docsUrl = "https://docs.autohand.ai";
   const websiteLink = _terminallink2.default.call(void 0, theme.link("autohand.ai"), websiteUrl);
   const githubLink = _terminallink2.default.call(void 0, theme.link("github.com/autohandai/"), githubUrl);
   const docsLink = _terminallink2.default.call(void 0, theme.link("docs.autohand.ai"), docsUrl);
-  lines.push(`${theme.text("\u{1F310}")} ${theme.text(_chunkCHI52KFRcjs.t.call(void 0, "commands.about.website") + ":")}    ${websiteLink}`);
-  lines.push(`${theme.text("\u{1F4E6}")} ${theme.text(_chunkCHI52KFRcjs.t.call(void 0, "commands.about.github") + ":")}     ${githubLink}`);
-  lines.push(`${theme.text("\u{1F4DA}")} ${theme.text(_chunkCHI52KFRcjs.t.call(void 0, "commands.about.docs") + ":")}       ${docsLink}`);
+  lines.push(`${theme.text("\u{1F310}")} ${theme.text(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.about.website") + ":")}    ${websiteLink}`);
+  lines.push(`${theme.text("\u{1F4E6}")} ${theme.text(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.about.github") + ":")}     ${githubLink}`);
+  lines.push(`${theme.text("\u{1F4DA}")} ${theme.text(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.about.docs") + ":")}       ${docsLink}`);
   lines.push("");
-  lines.push(theme.text(`\u{1F4A1} ${_chunkCHI52KFRcjs.t.call(void 0, "commands.about.contribute")}`));
-  lines.push(theme.text(`   \u2022 ${_chunkCHI52KFRcjs.t.call(void 0, "commands.about.feedback")}:     ${theme.accent("/feedback")}`));
-  lines.push(theme.text(`   \u2022 ${_chunkCHI52KFRcjs.t.call(void 0, "commands.about.submitPR")}:         ${theme.accent("gh pr create")}`));
+  lines.push(theme.text(`\u{1F4A1} ${_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.about.contribute")}`));
+  lines.push(theme.text(`   \u2022 ${_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.about.feedback")}:     ${theme.accent("/feedback")}`));
+  lines.push(theme.text(`   \u2022 ${_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.about.submitPR")}:         ${theme.accent("gh pr create")}`));
   const issuesUrl = "https://github.com/autohandai/code-cli/issues";
   const issuesLink = _terminallink2.default.call(void 0, theme.link("github.com/autohandai/code-cli/issues"), issuesUrl);
-  lines.push(theme.text(`   \u2022 ${_chunkCHI52KFRcjs.t.call(void 0, "commands.about.reportIssues")}:     ${issuesLink}`));
+  lines.push(theme.text(`   \u2022 ${_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.about.reportIssues")}:     ${issuesLink}`));
   return lines.join("\n");
 }
 var metadata = {