autohand-cli 0.9.0 → 0.9.2

package/dist/{chunk-FGT6KK6T.js → chunk-RMVONICR.js}

@@ -1,9 +1,9 @@
 import {
   showModal
-} from "./chunk-DLP436GI.js";
+} from "./chunk-LOSXLH7P.js";
 import {
   saveConfig
-} from "./chunk-3UT7R3XV.js";
+} from "./chunk-CM24K6ZT.js";
 import {
   CUSTOM_THEMES_DIR,
   builtInThemes,
@@ -16,7 +16,7 @@ import {
 } from "./chunk-JAQO6XDB.js";
 import {
   t
-} from "./chunk-CBFH2J3O.js";
+} from "./chunk-SJQU2ZFR.js";
 
 // src/commands/theme.ts
 import chalk from "chalk";

package/dist/{chunk-Q6AC3PHY.cjs → chunk-RPSYRJL7.cjs}

@@ -1,7 +1,10 @@
 "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 _class;
 
+var _chunkB55VCYSQcjs = require('./chunk-B55VCYSQ.cjs');
 
-var _chunkE26KKI46cjs = require('./chunk-E26KKI46.cjs');
+
+
+var _chunk3JURXAL6cjs = require('./chunk-3JURXAL6.cjs');
 
 // src/memory/MemoryManager.ts
 var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
@@ -12,13 +15,13 @@ var MemoryManager = (_class = class {
   
   __init() {this.projectMemoryDir = null}
   constructor(workspaceRoot) {;_class.prototype.__init.call(this);
-    this.userMemoryDir = _chunkE26KKI46cjs.AUTOHAND_PATHS.memory;
+    this.userMemoryDir = _chunk3JURXAL6cjs.AUTOHAND_PATHS.memory;
     if (workspaceRoot) {
-      this.projectMemoryDir = _path2.default.join(workspaceRoot, _chunkE26KKI46cjs.PROJECT_DIR_NAME, "memory");
+      this.projectMemoryDir = _path2.default.join(workspaceRoot, _chunk3JURXAL6cjs.PROJECT_DIR_NAME, "memory");
     }
   }
   setWorkspace(workspaceRoot) {
-    this.projectMemoryDir = _path2.default.join(workspaceRoot, _chunkE26KKI46cjs.PROJECT_DIR_NAME, "memory");
+    this.projectMemoryDir = _path2.default.join(workspaceRoot, _chunk3JURXAL6cjs.PROJECT_DIR_NAME, "memory");
   }
   async initialize() {
     await _fsextra2.default.ensureDir(this.userMemoryDir);
@@ -55,6 +58,7 @@ var MemoryManager = (_class = class {
     const entryPath = _path2.default.join(dir, `${id}.json`);
     await _fsextra2.default.writeJson(entryPath, entry, { spaces: 2 });
     await this.updateIndex(level, entry);
+    _chunkB55VCYSQcjs.scheduleBackgroundSync.call(void 0, );
     return entry;
   }
   async updateMemory(id, content, level, tags) {
@@ -72,6 +76,7 @@ var MemoryManager = (_class = class {
     };
     await _fsextra2.default.writeJson(entryPath, updated, { spaces: 2 });
     await this.updateIndex(level, updated);
+    _chunkB55VCYSQcjs.scheduleBackgroundSync.call(void 0, );
     return updated;
   }
   async get(id, level) {
@@ -117,6 +122,7 @@ var MemoryManager = (_class = class {
     if (await _fsextra2.default.pathExists(entryPath)) {
       await _fsextra2.default.remove(entryPath);
       await this.removeFromIndex(level, id);
+      _chunkB55VCYSQcjs.scheduleBackgroundSync.call(void 0, );
     }
   }
   async findSimilar(content, level) {

package/dist/chunk-RS2E32YB.js

@@ -0,0 +1,71 @@
+// src/session/chatLog.ts
+function decodeJsonStringLiteral(value) {
+  try {
+    return JSON.parse(`"${value}"`);
+  } catch {
+    return value;
+  }
+}
+function extractJsonStringField(raw, field) {
+  const match = raw.match(new RegExp(`"${field}"\\s*:\\s*"((?:\\\\.|[^"\\\\])*)"`, "s"));
+  return match?.[1] ? decodeJsonStringLiteral(match[1]) : null;
+}
+function getAssistantChatLogContent(content) {
+  const trimmed = content.trim();
+  if (!trimmed) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    for (const field of ["finalResponse", "response", "content", "message"]) {
+      const value = parsed[field];
+      if (typeof value === "string" && value.trim()) {
+        return value.trim();
+      }
+    }
+    return null;
+  } catch {
+    const finalResponse = extractJsonStringField(trimmed, "finalResponse") ?? extractJsonStringField(trimmed, "response");
+    if (finalResponse?.trim()) {
+      return finalResponse.trim();
+    }
+    if (trimmed.startsWith("{") || trimmed.includes('"thought"')) {
+      return null;
+    }
+    return trimmed;
+  }
+}
+function buildSessionChatLog(messages) {
+  const chatMessages = [];
+  for (const message of messages) {
+    if (message.role === "user") {
+      const content = message.content.trim();
+      if (content) {
+        chatMessages.push({ role: "user", content });
+      }
+      continue;
+    }
+    if (message.role === "assistant") {
+      const content = getAssistantChatLogContent(message.content);
+      if (content) {
+        chatMessages.push({ role: "assistant", content });
+      }
+    }
+  }
+  return chatMessages;
+}
+function formatChatLogPreview(content, maxLength = 100) {
+  const singleLine = content.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
+  return singleLine.length > maxLength ? `${singleLine.slice(0, maxLength)}...` : singleLine;
+}
+
+export {
+  getAssistantChatLogContent,
+  buildSessionChatLog,
+  formatChatLogPreview
+};
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-RWKU2X7O.js

@@ -0,0 +1,388 @@
+import {
+  formatAccount
+} from "./chunk-ZUYYHKQA.js";
+import {
+  createCommandTheme
+} from "./chunk-46MTALKD.js";
+import {
+  getProviderConfig
+} from "./chunk-CM24K6ZT.js";
+import {
+  getFeatureState
+} from "./chunk-H7HXRRHK.js";
+
+// src/commands/usage.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+// src/core/context/types.ts
+var CONTEXT_ENV_VARS = {
+  /** Enable/disable context compaction ('true' | 'false'). */
+  CONTEXT_COMPACT: "AUTOHAND_CONTEXT_COMPACT",
+  /** Override context window size (number). */
+  CONTEXT_WINDOW: "AUTOHAND_CONTEXT_WINDOW",
+  /** Tokens to reserve for model output (number). */
+  RESERVE_TOKENS: "AUTOHAND_RESERVE_TOKENS"
+};
+
+// src/core/context/tokenizer.ts
+var MODEL_CONTEXT = {
+  "anthropic/claude-4-sonnet": 2e5,
+  "anthropic/claude-3-opus": 2e5,
+  "anthropic/claude-3-haiku": 2e5,
+  "anthropic/claude-opus-4": 2e5,
+  "anthropic/claude-opus-4-7": 1e6,
+  "openai/gpt-4o-mini": 128e3,
+  "openai/gpt-4o": 128e3,
+  "openai/gpt-4.1": 2e5,
+  "openai/o1": 2e5,
+  "openai/o1-mini": 128e3,
+  "tencent/hy3-preview:free": 262144,
+  "tencent/hy3-preview-20260421:free": 262144,
+  "deepseek/deepseek-r1": 64e3,
+  "deepseek/deepseek-r1-0528-qwen3-8b:free": 8e3,
+  "deepseek/deepseek-coder": 16e3
+};
+var SAFETY_MARGIN = 0.9;
+var CONTEXT_WARNING_THRESHOLD = 0.8;
+var CONTEXT_CRITICAL_THRESHOLD = 0.9;
+function parseContextWindowOverride(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return void 0;
+  }
+  return Math.floor(value);
+}
+function normalizeModelId(model) {
+  return model.trim().toLowerCase().replace(/^openai\//, "").replace(/^google\//, "").replace(/^deepseek\//, "").replace(/^zai\//, "").replace(/^sakana\//, "");
+}
+function inferContextWindow(model) {
+  const normalized = normalizeModelId(model);
+  if (normalized.startsWith("gpt-5.5")) return 105e4;
+  if (normalized.startsWith("gpt-5.4") && !normalized.includes("mini") && !normalized.includes("nano")) return 105e4;
+  if (normalized.startsWith("gpt-5.4-mini") || normalized.startsWith("gpt-5.4-nano") || normalized.startsWith("gpt-5.3-codex") || normalized === "gpt-5" || normalized.startsWith("gpt-5-mini") || normalized.startsWith("gpt-5-nano")) {
+    return 4e5;
+  }
+  if (normalized.startsWith("gpt-5.3-chat")) return 128e3;
+  if (normalized.startsWith("gemini-3.1-flash-image")) return 128e3;
+  if (normalized.startsWith("gemini-3-pro-image")) return 65e3;
+  if (normalized.startsWith("gemini-3.1-pro") || normalized.startsWith("gemini-3.1-flash-lite") || normalized.startsWith("gemini-3-flash")) {
+    return 1e6;
+  }
+  if (normalized.startsWith("deepseek-v4")) return 1e6;
+  if (normalized.startsWith("glm-5.2")) return 1e6;
+  if (normalized.startsWith("glm-5.1")) return 2e5;
+  if (normalized === "fugu" || normalized === "fugu-ultra") return 1e6;
+  return void 0;
+}
+function getContextWindow(model, configuredContextWindow) {
+  const envOverride = process.env[CONTEXT_ENV_VARS.CONTEXT_WINDOW];
+  if (envOverride) {
+    const parsed = parseInt(envOverride, 10);
+    if (!isNaN(parsed) && parsed > 0) return parsed;
+  }
+  const configured = parseContextWindowOverride(configuredContextWindow);
+  if (configured) return configured;
+  const normalized = model.toLowerCase();
+  if (MODEL_CONTEXT[normalized]) {
+    return MODEL_CONTEXT[normalized];
+  }
+  const inferred = inferContextWindow(model);
+  if (inferred) return inferred;
+  const fuzzy = Object.entries(MODEL_CONTEXT).find(
+    ([name]) => normalized.includes(name) || name.includes(normalized.split("/").pop() ?? "")
+  );
+  return fuzzy ? fuzzy[1] : 128e3;
+}
+function getModelFamily(model) {
+  const normalized = model.toLowerCase();
+  if (normalized.includes("claude")) return "claude";
+  if (normalized.includes("gpt-4") || normalized.includes("gpt-5") || normalized.includes("o1") || normalized.includes("o3")) return "openai";
+  if (normalized.includes("gemini")) return "gemini";
+  if (normalized.includes("deepseek")) return "deepseek";
+  return "default";
+}
+function estimateTokens(text, modelFamily) {
+  if (!text) return 0;
+  const codeLikeChars = text.match(/[{}[\]":\\]/g)?.length ?? 0;
+  const codeLikeRatio = text.length > 200 && codeLikeChars >= 4 ? 0.65 : 1;
+  const baseRatio = {
+    openai: 4,
+    claude: 3.5,
+    gemini: 4,
+    deepseek: 3,
+    default: 3.5
+  };
+  const ratio = (baseRatio[modelFamily ?? "default"] ?? 3.5) * codeLikeRatio;
+  return Math.ceil(text.length / ratio);
+}
+function estimateMessageTokens(message, modelFamily) {
+  const structureOverhead = 10;
+  let tokens = structureOverhead;
+  tokens += estimateTokens(message.content ?? "", modelFamily);
+  if (message.tool_calls) {
+    for (const call of message.tool_calls) {
+      tokens += 5;
+      tokens += estimateTokens(call.function.name, modelFamily);
+      tokens += estimateTokens(call.function.arguments, modelFamily);
+    }
+  }
+  return tokens;
+}
+function estimateMessagesTokens(messages, modelFamily) {
+  return messages.reduce(
+    (acc, message) => acc + estimateMessageTokens(message, modelFamily),
+    0
+  );
+}
+function estimateToolsTokens(tools, modelFamily) {
+  if (!tools || tools.length === 0) return 0;
+  let tokens = 0;
+  for (const tool of tools) {
+    tokens += estimateTokens(tool.name, modelFamily);
+    tokens += estimateTokens(tool.description, modelFamily);
+    if (tool.parameters) {
+      const paramJson = JSON.stringify(tool.parameters);
+      tokens += estimateTokens(paramJson, modelFamily);
+    }
+    tokens += 35;
+  }
+  return tokens;
+}
+function calculateContextUsage(messages, tools, model, outputBudget = 16e3, configuredContextWindow) {
+  const envReserve = process.env[CONTEXT_ENV_VARS.RESERVE_TOKENS];
+  if (envReserve) {
+    const parsed = parseInt(envReserve, 10);
+    if (!isNaN(parsed) && parsed > 0) outputBudget = parsed;
+  }
+  const modelFamily = getModelFamily(model);
+  const messagesTokens = estimateMessagesTokens(messages, modelFamily);
+  const toolsTokens = estimateToolsTokens(tools, modelFamily);
+  const totalTokens = messagesTokens + toolsTokens;
+  const contextWindow = getContextWindow(model, configuredContextWindow);
+  const cappedOutputBudget = Math.min(outputBudget, Math.floor(contextWindow * 0.25));
+  const effectiveWindow = contextWindow - cappedOutputBudget;
+  const safeWindow = Math.floor(effectiveWindow * SAFETY_MARGIN);
+  const usagePercent = totalTokens / effectiveWindow;
+  return {
+    totalTokens,
+    messagesTokens,
+    toolsTokens,
+    contextWindow,
+    safeWindow,
+    usagePercent,
+    isWarning: usagePercent >= CONTEXT_WARNING_THRESHOLD,
+    isCritical: usagePercent >= CONTEXT_CRITICAL_THRESHOLD,
+    isExceeded: totalTokens >= safeWindow,
+    remainingTokens: Math.max(0, safeWindow - totalTokens)
+  };
+}
+
+// src/commands/usage.ts
+var USAGE_V2_FLAG = "usage_v2";
+var metadata = {
+  command: "/usage",
+  description: "Show model, provider, context, and usage limits",
+  implemented: true
+};
+function clampPercent(value) {
+  if (!Number.isFinite(value)) return 100;
+  return Math.max(0, Math.min(100, Math.round(value)));
+}
+function formatPath(value) {
+  const home = os.homedir();
+  if (value === home) {
+    return "~";
+  }
+  if (value.startsWith(`${home}${path.sep}`)) {
+    return `~${value.slice(home.length)}`;
+  }
+  return value;
+}
+function formatCompactNumber(value) {
+  if (!Number.isFinite(value) || value < 0) {
+    return "0";
+  }
+  if (value >= 1e6) {
+    const millions = value / 1e6;
+    return `${Number.isInteger(millions) ? millions.toFixed(0) : millions.toFixed(1)}M`;
+  }
+  if (value >= 1e3) {
+    const thousands = value / 1e3;
+    return `${Number.isInteger(thousands) ? thousands.toFixed(0) : thousands.toFixed(1)}K`;
+  }
+  return String(Math.round(value));
+}
+function formatPermissionMode(mode) {
+  switch (mode ?? "interactive") {
+    case "interactive":
+      return "Workspace (on-request)";
+    case "unrestricted":
+      return "Workspace (full access)";
+    case "restricted":
+      return "Read-only (restricted)";
+    case "external":
+      return "External approval";
+  }
+}
+function resolveProviderSettings(config, provider) {
+  if (!config || !provider) {
+    return void 0;
+  }
+  return getProviderConfig(config, provider) ?? void 0;
+}
+function resolveActiveProvider(ctx) {
+  return ctx.config?.provider ?? ctx.provider ?? "openrouter";
+}
+function resolveActiveModel(ctx, provider) {
+  const settings = resolveProviderSettings(ctx.config, provider);
+  return settings?.model ?? ctx.model;
+}
+function resolveReasoningEffort(config, provider) {
+  return resolveProviderSettings(config, provider)?.reasoningEffort;
+}
+function resolveContextWindow(ctx, provider, model) {
+  const settings = resolveProviderSettings(ctx.config, provider);
+  return ctx.getContextWindow?.() ?? settings?.contextWindow ?? getContextWindow(model, settings?.contextWindow);
+}
+function resolveContextTokensUsed(ctx, contextWindow, percentLeft) {
+  const reported = ctx.getTotalTokensUsed?.();
+  if (typeof reported === "number" && Number.isFinite(reported) && reported > 0) {
+    return Math.round(reported);
+  }
+  return Math.round(contextWindow * ((100 - percentLeft) / 100));
+}
+function resolveAgentsFile(workspaceRoot) {
+  return fs.existsSync(path.join(workspaceRoot, "AGENTS.md")) ? "AGENTS.md" : "none";
+}
+function resolveAccount(config) {
+  const account = formatAccount(config, "");
+  if (account) {
+    return account;
+  }
+  if (config?.openai?.authMode === "chatgpt" && config.openai.chatgptAuth?.accountId) {
+    return `ChatGPT account ${config.openai.chatgptAuth.accountId}`;
+  }
+  return "not signed in";
+}
+function isUsageV2Enabled(ctx) {
+  const localDefault = ctx.config ? getFeatureState(ctx.config, USAGE_V2_FLAG)?.enabled ?? false : false;
+  return ctx.isFeatureEnabled?.(USAGE_V2_FLAG, localDefault) ?? localDefault;
+}
+function gatherUsageDashboardData(ctx) {
+  const provider = resolveActiveProvider(ctx);
+  const model = resolveActiveModel(ctx, provider);
+  const contextPercentLeft = clampPercent(ctx.getContextPercentLeft?.() ?? 100);
+  const contextWindow = resolveContextWindow(ctx, provider, model);
+  const currentSession = ctx.sessionManager.getCurrentSession();
+  const usageLimits = ctx.getUsageLimits?.() ?? [];
+  return {
+    model,
+    provider,
+    directory: formatPath(ctx.workspaceRoot),
+    permissions: formatPermissionMode(ctx.config?.permissions?.mode),
+    agentsFile: resolveAgentsFile(ctx.workspaceRoot),
+    account: resolveAccount(ctx.config),
+    sessionId: currentSession?.metadata.sessionId ?? "none",
+    contextPercentLeft,
+    contextWindow,
+    contextTokensUsed: resolveContextTokensUsed(ctx, contextWindow, contextPercentLeft),
+    tokenUsageStatus: ctx.getTokenUsageStatus?.() ?? "actual",
+    reasoningEffort: resolveReasoningEffort(ctx.config, provider),
+    usageLimits
+  };
+}
+function formatProgressBar(percentLeft, width = 24) {
+  const emptySlots = Math.round(percentLeft / 100 * width);
+  const usedSlots = width - emptySlots;
+  return `[${"\u2588".repeat(emptySlots)}${"\u2591".repeat(usedSlots)}]`;
+}
+function formatInfoRow(label, value, labelWidth) {
+  const theme = createCommandTheme();
+  return `${theme.muted(label.padEnd(labelWidth))} ${value}`;
+}
+function formatModel(data) {
+  if (!data.reasoningEffort) {
+    return data.model;
+  }
+  return `${data.model} ${createCommandTheme().muted(`(reasoning ${data.reasoningEffort})`)}`;
+}
+function formatContextSummary(data) {
+  const used = formatCompactNumber(data.contextTokensUsed);
+  const window = formatCompactNumber(data.contextWindow);
+  const suffix = data.tokenUsageStatus === "unavailable" ? " estimated" : "";
+  return `${data.contextPercentLeft}% left ${createCommandTheme().muted(`(${used} used / ${window}${suffix})`)}`;
+}
+function formatUsageLimitRow(row, labelWidth) {
+  if (row.unavailableReason) {
+    return formatInfoRow(`${row.label}:`, row.unavailableReason, labelWidth);
+  }
+  const percent = clampPercent(row.percentLeft ?? 100);
+  const reset = row.resetLabel ? createCommandTheme().muted(` (${row.resetLabel})`) : "";
+  const usage2 = typeof row.used === "number" && typeof row.limit === "number" ? createCommandTheme().muted(` (${formatCompactNumber(row.used)} used / ${formatCompactNumber(row.limit)})`) : "";
+  return formatInfoRow(`${row.label}:`, `${formatProgressBar(percent)} ${percent}% left${reset}${usage2}`, labelWidth);
+}
+function formatUsageDashboard(data) {
+  const labelWidth = 24;
+  const providerLimitRows = data.usageLimits.length > 0 ? data.usageLimits : [{ label: String(data.provider), unavailableReason: "not reported by provider" }];
+  const lines = [
+    formatInfoRow("Model:", formatModel(data), labelWidth),
+    formatInfoRow("Provider:", String(data.provider), labelWidth),
+    formatInfoRow("Directory:", data.directory, labelWidth),
+    formatInfoRow("Permissions:", data.permissions, labelWidth),
+    formatInfoRow("Agents.md:", data.agentsFile, labelWidth),
+    formatInfoRow("Account:", data.account, labelWidth),
+    formatInfoRow("Session:", data.sessionId, labelWidth),
+    "",
+    formatInfoRow("Context window:", formatContextSummary(data), labelWidth),
+    formatInfoRow("", formatProgressBar(data.contextPercentLeft), labelWidth),
+    "",
+    formatInfoRow("Provider limits:", "", labelWidth).trimEnd(),
+    ...providerLimitRows.map((row) => formatUsageLimitRow(row, labelWidth))
+  ];
+  return lines.join("\n");
+}
+async function usage(ctx) {
+  if (!isUsageV2Enabled(ctx)) {
+    return "The /usage dashboard is behind usage_v2. Run /experiments enable usage_v2, then /usage again. No restart required.";
+  }
+  await ctx.trackFeatureActivation?.(USAGE_V2_FLAG, {
+    provider: ctx.provider,
+    model: ctx.model
+  });
+  return formatUsageDashboard(gatherUsageDashboardData(ctx));
+}
+
+export {
+  CONTEXT_ENV_VARS,
+  getContextWindow,
+  estimateMessageTokens,
+  estimateMessagesTokens,
+  calculateContextUsage,
+  USAGE_V2_FLAG,
+  metadata,
+  gatherUsageDashboardData,
+  formatUsageDashboard,
+  usage
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Domain types for the context-compaction module.
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Token estimation, context window lookup, and usage calculation.
+ * Moved from src/utils/context.ts — this is the canonical location.
+ * The old barrel re-exports for backward compatibility.
+ */
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */