autohand-cli 0.7.4 → 0.7.6

package/dist/chunk-723DZKBU.js

@@ -0,0 +1,613 @@
+import {
+  package_default
+} from "./chunk-5MCDN53U.js";
+import {
+  AUTOHAND_PATHS
+} from "./chunk-FUEL6BK7.js";
+
+// src/commands/share.ts
+import chalk from "chalk";
+import enquirer from "enquirer";
+import ora from "ora";
+
+// src/share/costEstimator.ts
+var DEFAULT_COST_PER_1K_TOKENS = 3e-3;
+function estimateCost(totalTokens) {
+  if (totalTokens <= 0) return 0;
+  const cost = totalTokens / 1e3 * DEFAULT_COST_PER_1K_TOKENS;
+  return Math.round(cost * 1e4) / 1e4;
+}
+function formatCost(cost) {
+  if (cost < 0.01) {
+    if (cost === 0) return "$0.00";
+    return `$${cost.toFixed(4)}`;
+  }
+  return `$${cost.toFixed(2)}`;
+}
+function formatTokens(tokens) {
+  if (tokens >= 1e6) {
+    return `${(tokens / 1e6).toFixed(1)}M`;
+  }
+  if (tokens >= 1e3) {
+    return `${(tokens / 1e3).toFixed(1)}K`;
+  }
+  return tokens.toString();
+}
+function formatDuration(seconds) {
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  if (minutes < 60) {
+    if (remainingSeconds === 0) return `${minutes}m`;
+    return `${minutes}m ${remainingSeconds}s`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  if (remainingMinutes === 0) return `${hours}h`;
+  return `${hours}h ${remainingMinutes}m`;
+}
+
+// src/share/sessionSerializer.ts
+function extractToolUsage(messages) {
+  const toolCounts = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (message.role === "assistant" && message.toolCalls) {
+      for (const toolCall of message.toolCalls) {
+        const toolName = toolCall.function?.name || toolCall.name || "unknown";
+        const current = toolCounts.get(toolName) || { total: 0, success: 0 };
+        current.total++;
+        toolCounts.set(toolName, current);
+      }
+    }
+    if (message.role === "tool" && message.name) {
+      const current = toolCounts.get(message.name);
+      if (current) {
+        const isError = message.content.toLowerCase().includes("error") || message.content.toLowerCase().includes("failed");
+        if (!isError) {
+          current.success++;
+        }
+      }
+    }
+  }
+  const result = [];
+  for (const [name, counts] of toolCounts) {
+    result.push({
+      name,
+      count: counts.total,
+      successRate: counts.total > 0 ? counts.success / counts.total : void 0
+    });
+  }
+  return result.sort((a, b) => b.count - a.count);
+}
+function estimateTokensFromMessages(messages) {
+  let input = 0;
+  let output = 0;
+  for (const message of messages) {
+    const chars = message.content.length;
+    const tokens = Math.ceil(chars / 4);
+    if (message.role === "user" || message.role === "system") {
+      input += tokens;
+    } else {
+      output += tokens;
+    }
+  }
+  return {
+    total: input + output,
+    input,
+    output
+  };
+}
+function parseGitDiff(diffContent) {
+  if (!diffContent || diffContent.trim().length === 0) {
+    return void 0;
+  }
+  const lines = diffContent.split("\n");
+  const filesChanged = /* @__PURE__ */ new Set();
+  let linesAdded = 0;
+  let linesRemoved = 0;
+  for (const line of lines) {
+    if (line.startsWith("diff --git")) {
+      const match = line.match(/diff --git a\/(.+) b\/(.+)/);
+      if (match) {
+        filesChanged.add(match[2]);
+      }
+    } else if (line.startsWith("+") && !line.startsWith("+++")) {
+      linesAdded++;
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      linesRemoved++;
+    }
+  }
+  if (filesChanged.size === 0 && linesAdded === 0 && linesRemoved === 0) {
+    return void 0;
+  }
+  return {
+    filesChanged: Array.from(filesChanged),
+    linesAdded,
+    linesRemoved,
+    diffContent
+  };
+}
+function calculateDuration(startedAt, endedAt) {
+  const start = new Date(startedAt).getTime();
+  const end = new Date(endedAt).getTime();
+  return Math.max(0, Math.floor((end - start) / 1e3));
+}
+function serializeSession(session, options) {
+  const messages = session.getMessages();
+  const { metadata: metadata2 } = session;
+  const endedAt = metadata2.closedAt || (/* @__PURE__ */ new Date()).toISOString();
+  const durationSeconds = calculateDuration(metadata2.createdAt, endedAt);
+  const sessionMetadata = {
+    sessionId: metadata2.sessionId,
+    projectName: metadata2.projectName,
+    model: options.model || metadata2.model,
+    provider: options.provider || "openrouter",
+    startedAt: metadata2.createdAt,
+    endedAt,
+    durationSeconds,
+    messageCount: messages.length,
+    status: metadata2.status,
+    summary: metadata2.summary
+  };
+  let usage;
+  if (options.totalTokens && options.totalTokens > 0) {
+    const inputTokens = Math.floor(options.totalTokens * 0.3);
+    const outputTokens = options.totalTokens - inputTokens;
+    usage = {
+      totalTokens: options.totalTokens,
+      inputTokens,
+      outputTokens,
+      estimatedCost: estimateCost(options.totalTokens)
+    };
+  } else {
+    const estimated = estimateTokensFromMessages(messages);
+    usage = {
+      totalTokens: estimated.total,
+      inputTokens: estimated.input,
+      outputTokens: estimated.output,
+      estimatedCost: estimateCost(estimated.total)
+    };
+  }
+  const toolUsage = extractToolUsage(messages);
+  const gitDiff = options.gitDiff ? parseGitDiff(options.gitDiff) : void 0;
+  const client = {
+    cliVersion: package_default.version,
+    platform: process.platform,
+    deviceId: options.deviceId
+  };
+  const sharedMessages = messages.map((msg) => ({
+    role: msg.role,
+    content: msg.content,
+    timestamp: msg.timestamp,
+    name: msg.name,
+    toolCalls: msg.toolCalls,
+    tool_call_id: msg.tool_call_id
+  }));
+  return {
+    metadata: sessionMetadata,
+    usage,
+    toolUsage,
+    gitDiff,
+    messages: sharedMessages,
+    visibility: options.visibility,
+    client,
+    userId: options.userId
+  };
+}
+
+// src/share/ShareApiClient.ts
+import fs from "fs-extra";
+import path from "path";
+function getBaseUrl() {
+  return process.env.AUTOHAND_SHARE_URL || "https://autohand.link/api";
+}
+var DEFAULT_CONFIG = {
+  baseUrl: getBaseUrl(),
+  timeout: 3e4,
+  // 30s for large payloads
+  maxRetries: 3,
+  offlineQueue: true,
+  cliVersion: package_default.version
+};
+var ShareApiClient = class {
+  constructor(configOverrides) {
+    this.deviceId = null;
+    this.config = { ...DEFAULT_CONFIG, ...configOverrides };
+    const dataDir = path.join(AUTOHAND_PATHS.config, "share");
+    this.queuePath = path.join(dataDir, "queue.json");
+    this.deviceIdPath = path.join(AUTOHAND_PATHS.feedback, ".device-id");
+  }
+  // ============ Device ID ============
+  /**
+   * Get or create anonymous device identifier
+   * Shared with FeedbackApiClient for consistency
+   */
+  async getDeviceId() {
+    if (this.deviceId) return this.deviceId;
+    try {
+      if (await fs.pathExists(this.deviceIdPath)) {
+        this.deviceId = (await fs.readFile(this.deviceIdPath, "utf8")).trim();
+        return this.deviceId;
+      }
+    } catch {
+    }
+    this.deviceId = `anon_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+    try {
+      await fs.ensureDir(path.dirname(this.deviceIdPath));
+      await fs.writeFile(this.deviceIdPath, this.deviceId);
+    } catch {
+    }
+    return this.deviceId;
+  }
+  // ============ Create Share ============
+  /**
+   * Upload a session to create a shareable link
+   */
+  async createShare(payload) {
+    try {
+      const response = await this.sendToApi("POST", "/share", payload);
+      if (response.success) {
+        this.flushQueue().catch(() => {
+        });
+      }
+      return response;
+    } catch (error) {
+      if (this.config.offlineQueue) {
+        await this.addToQueue(payload);
+        return {
+          success: false,
+          error: `Queued for retry: ${error.message}`
+        };
+      }
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+  // ============ Delete Share ============
+  /**
+   * Delete a shared session (owner only)
+   */
+  async deleteShare(shareId) {
+    const deviceId = await this.getDeviceId();
+    try {
+      const response = await this.sendToApi(
+        "DELETE",
+        `/share/${shareId}`,
+        void 0,
+        { "X-Device-ID": deviceId }
+      );
+      return response;
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+  // ============ API Communication ============
+  /**
+   * Send request to API endpoint
+   */
+  async sendToApi(method, endpoint, body, extraHeaders) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const headers = {
+        "Content-Type": "application/json",
+        "X-CLI-Version": this.config.cliVersion,
+        ...extraHeaders
+      };
+      const response = await fetch(`${this.config.baseUrl}${endpoint}`, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "Unknown error");
+        throw new Error(`API error: ${response.status} ${errorText}`);
+      }
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        throw new Error("Request timeout");
+      }
+      throw error;
+    }
+  }
+  // ============ Offline Queue ============
+  /**
+   * Add share to offline queue
+   */
+  async addToQueue(payload) {
+    try {
+      let queue = [];
+      if (await fs.pathExists(this.queuePath)) {
+        queue = await fs.readJson(this.queuePath);
+      }
+      queue.push({
+        payload,
+        attempts: 0,
+        lastAttempt: (/* @__PURE__ */ new Date()).toISOString(),
+        id: `q_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`
+      });
+      if (queue.length > 10) {
+        queue = queue.slice(-10);
+      }
+      await fs.ensureDir(path.dirname(this.queuePath));
+      await fs.writeJson(this.queuePath, queue, { spaces: 2 });
+    } catch {
+    }
+  }
+  /**
+   * Attempt to flush queued shares
+   */
+  async flushQueue() {
+    let sent = 0;
+    let failed = 0;
+    try {
+      if (!await fs.pathExists(this.queuePath)) {
+        return { sent, failed };
+      }
+      const queue = await fs.readJson(this.queuePath);
+      const remaining = [];
+      for (const item of queue) {
+        if (item.attempts >= this.config.maxRetries) {
+          failed++;
+          continue;
+        }
+        try {
+          const response = await this.sendToApi("POST", "/share", item.payload);
+          if (response.success) {
+            sent++;
+          } else {
+            item.attempts++;
+            item.lastAttempt = (/* @__PURE__ */ new Date()).toISOString();
+            remaining.push(item);
+            failed++;
+          }
+        } catch {
+          item.attempts++;
+          item.lastAttempt = (/* @__PURE__ */ new Date()).toISOString();
+          remaining.push(item);
+          failed++;
+        }
+      }
+      if (remaining.length > 0) {
+        await fs.writeJson(this.queuePath, remaining, { spaces: 2 });
+      } else {
+        await fs.remove(this.queuePath);
+      }
+    } catch {
+    }
+    return { sent, failed };
+  }
+  /**
+   * Get queue status
+   */
+  async getQueueStatus() {
+    try {
+      if (!await fs.pathExists(this.queuePath)) {
+        return { pending: 0, oldestItem: null };
+      }
+      const queue = await fs.readJson(this.queuePath);
+      return {
+        pending: queue.length,
+        oldestItem: queue[0]?.lastAttempt || null
+      };
+    } catch {
+      return { pending: 0, oldestItem: null };
+    }
+  }
+  // ============ Health Check ============
+  /**
+   * Check if API is reachable
+   */
+  async healthCheck() {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 5e3);
+      const response = await fetch(`${this.config.baseUrl}/health`, {
+        method: "GET",
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+var instance = null;
+var instanceBaseUrl = null;
+function getShareApiClient(config) {
+  const currentBaseUrl = config?.baseUrl || getBaseUrl();
+  if (instance && instanceBaseUrl !== currentBaseUrl) {
+    instance = null;
+  }
+  if (!instance) {
+    instance = new ShareApiClient(config);
+    instanceBaseUrl = currentBaseUrl;
+  }
+  return instance;
+}
+
+// src/commands/share.ts
+function terminalLink(url, text) {
+  const displayText = text || url;
+  const OSC = "\x1B]8;;";
+  const ST = "\x1B\\";
+  return `${OSC}${url}${ST}${chalk.cyan.underline(displayText)}${OSC}${ST}`;
+}
+var metadata = {
+  command: "/share",
+  description: "Share current session via public URL",
+  implemented: true
+};
+async function execute(_args, context) {
+  if (context?.config?.share?.enabled === false) {
+    console.log(chalk.yellow("Session sharing is disabled."));
+    console.log(
+      chalk.gray("To enable, set share.enabled: true in your config file.")
+    );
+    return;
+  }
+  if (!context?.currentSession) {
+    console.log(chalk.yellow("No active session to share."));
+    console.log(
+      chalk.gray("Start a conversation first, then use /share to share it.")
+    );
+    return;
+  }
+  const session = context.currentSession;
+  const messages = session.getMessages();
+  if (messages.length === 0) {
+    console.log(chalk.yellow("Session has no messages to share."));
+    return;
+  }
+  const client = getShareApiClient();
+  const deviceId = await client.getDeviceId();
+  const totalTokens = context.getTotalTokensUsed?.() ?? 0;
+  const duration = calculateDuration2(session.metadata.createdAt);
+  console.log();
+  console.log(chalk.bold("Session Summary"));
+  console.log(chalk.gray("\u2500".repeat(40)));
+  console.log(`  Project:   ${chalk.cyan(session.metadata.projectName)}`);
+  console.log(`  Model:     ${chalk.cyan(context.model)}`);
+  console.log(`  Messages:  ${chalk.cyan(messages.length)}`);
+  console.log(`  Tokens:    ${chalk.cyan(formatTokens(totalTokens))}`);
+  console.log(
+    `  Est. Cost: ${chalk.green(formatCost(totalTokens / 1e3 * 3e-3))}`
+  );
+  console.log(`  Duration:  ${chalk.cyan(formatDuration(duration))}`);
+  console.log();
+  const { Select, Confirm } = enquirer;
+  const visibilityPrompt = new Select({
+    name: "visibility",
+    message: "Share visibility:",
+    choices: [
+      { name: "public", message: "Public  - Anyone with the link can view" },
+      { name: "private", message: "Private - Requires one-time passcode" }
+    ]
+  });
+  let visibility;
+  try {
+    visibility = await visibilityPrompt.run();
+  } catch {
+    console.log(chalk.gray("Cancelled."));
+    return;
+  }
+  const confirmPrompt = new Confirm({
+    name: "confirm",
+    message: `Share this session as ${visibility}?`,
+    initial: true
+  });
+  let confirmed;
+  try {
+    confirmed = await confirmPrompt.run();
+  } catch {
+    console.log(chalk.gray("Cancelled."));
+    return;
+  }
+  if (!confirmed) {
+    console.log(chalk.gray("Cancelled."));
+    return;
+  }
+  console.log();
+  const spinner = ora("Uploading session...").start();
+  try {
+    const payload = serializeSession(session, {
+      model: context.model,
+      provider: context.provider,
+      totalTokens,
+      visibility,
+      deviceId
+    });
+    const response = await client.createShare(payload);
+    spinner.stop();
+    if (response.success && response.url) {
+      console.log();
+      console.log(chalk.green.bold("Session shared successfully!"));
+      console.log();
+      console.log(`${chalk.bold("URL:")} ${terminalLink(response.url)}`);
+      if (visibility === "private" && response.passcode) {
+        console.log();
+        console.log(`${chalk.bold("Passcode:")} ${chalk.yellow.bold(response.passcode)}`);
+        console.log(
+          chalk.gray("  Share this passcode with people who need access.")
+        );
+      }
+      console.log();
+      console.log(chalk.gray("Tip: Click the URL or copy it to share with others!"));
+      console.log();
+    } else {
+      console.log();
+      console.log(
+        chalk.red(`Failed to share: ${response.error || "Unknown error"}`)
+      );
+      console.log();
+    }
+  } catch (error) {
+    spinner.stop();
+    console.log();
+    console.log(chalk.red(`Failed to share: ${error.message}`));
+    console.log();
+  }
+}
+function calculateDuration2(startedAt) {
+  const start = new Date(startedAt).getTime();
+  const now = Date.now();
+  return Math.max(0, Math.floor((now - start) / 1e3));
+}
+
+export {
+  metadata,
+  execute
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Cost Estimator
+ * Simplified token cost estimation for session sharing
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Session Serializer
+ * Converts session data to ShareSessionPayload format
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Share API Client
+ * Handles communication with autohand.link for session sharing
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Share Module
+ * Session sharing functionality
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * /share Command
+ * Share current session via public URL
+ */

package/dist/chunk-JYTXG6OV.cjs

@@ -0,0 +1,102 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// package.json
+var package_default = {
+  name: "autohand-cli",
+  version: "0.7.6",
+  license: "Apache-2.0",
+  description: "Autohand interactive coding agent CLI powered by LLMs.",
+  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"
+  ],
+  scripts: {
+    go: 'bun run build && ./install-local.sh && echo "COMPLETED"',
+    build: "tsup",
+    dev: "bun src/index.ts",
+    typecheck: "tsc --noEmit",
+    lint: "eslint .",
+    test: "vitest run",
+    start: "node dist/index.js",
+    "compile:macos-arm64": "bun build ./src/index.ts --compile --target=bun-darwin-arm64 --external react-devtools-core --outfile ./binaries/autohand-macos-arm64",
+    "compile:macos-x64": "bun build ./src/index.ts --compile --target=bun-darwin-x64 --external react-devtools-core --outfile ./binaries/autohand-macos-x64",
+    "compile:linux-x64": "bun build ./src/index.ts --compile --target=bun-linux-x64 --external react-devtools-core --outfile ./binaries/autohand-linux-x64",
+    "compile:linux-arm64": "bun build ./src/index.ts --compile --target=bun-linux-arm64 --external react-devtools-core --outfile ./binaries/autohand-linux-arm64",
+    "compile:windows-x64": "bun build ./src/index.ts --compile --target=bun-windows-x64 --external react-devtools-core --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"
+  },
+  keywords: [
+    "cli",
+    "llm",
+    "agent",
+    "autohand"
+  ],
+  engines: {
+    node: ">=18.17.0"
+  },
+  dependencies: {
+    chalk: "^5.6.2",
+    commander: "^14.0.2",
+    diff: "^8.0.2",
+    dotenv: "^17.2.3",
+    enquirer: "^2.4.1",
+    "fs-extra": "^11.3.2",
+    ignore: "^5.3.1",
+    ink: "^4.4.1",
+    "ink-spinner": "^5.0.0",
+    minimatch: "^10.1.1",
+    open: "^10.1.0",
+    ora: "^9.0.0",
+    react: "^18.2.0",
+    "react-devtools-core": "^7.0.1",
+    "terminal-link": "^3.0.0",
+    yaml: "^2.8.2",
+    zod: "^4.1.12"
+  },
+  devDependencies: {
+    "@types/diff": "^8.0.0",
+    "@types/fs-extra": "^11.0.4",
+    "@types/minimatch": "^6.0.0",
+    "@types/node": "^24.10.1",
+    "@types/react": "^18.3.3",
+    "@types/terminal-link": "^1.2.0",
+    "@typescript-eslint/eslint-plugin": "^8.48.1",
+    "@typescript-eslint/parser": "^8.48.1",
+    eslint: "^9.39.1",
+    memfs: "^4.51.1",
+    tsup: "^8.5.1",
+    tsx: "^4.20.6",
+    typescript: "^5.9.3",
+    vitest: "^1.6.0"
+  },
+  overrides: {
+    ink: {
+      "slice-ansi": {
+        "ansi-styles": "^6.2.1"
+      },
+      "wrap-ansi": {
+        "ansi-styles": "^6.2.1"
+      },
+      "cli-truncate": {
+        "slice-ansi": {
+          "ansi-styles": "^6.2.1"
+        }
+      }
+    }
+  }
+};
+
+
+
+exports.package_default = package_default;