autohand-cli 0.8.2 → 0.9.0

package/dist/chunk-UWFG2R2I.cjs

@@ -0,0 +1,420 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunk3OF56EMAcjs = require('./chunk-3OF56EMA.cjs');
+
+// src/providers/NVIDIAClient.ts
+function sanitizeMessages(messages) {
+  return messages.map((msg) => {
+    const sanitized = {
+      role: msg.role,
+      content: msg.content
+    };
+    if (msg.role === "tool" && msg.tool_call_id) {
+      sanitized.tool_call_id = msg.tool_call_id;
+    }
+    if (msg.role === "assistant" && _optionalChain([msg, 'access', _ => _.tool_calls, 'optionalAccess', _2 => _2.length])) {
+      sanitized.tool_calls = msg.tool_calls;
+    }
+    if (msg.name) {
+      sanitized.name = msg.name;
+    }
+    return sanitized;
+  });
+}
+var NVIDIA_DEFAULT_BASE_URL = "https://integrate.api.nvidia.com/v1";
+var DEFAULT_MAX_RETRIES = 3;
+var MAX_ALLOWED_RETRIES = 5;
+var DEFAULT_RETRY_DELAY = 1e3;
+var DEFAULT_TIMEOUT = 3e4;
+var FRIENDLY_ERRORS = {
+  400: "The request was malformed. This often happens when the context is too long. Try /undo to remove recent turns or /new to start fresh.",
+  401: "Authentication failed. Please verify your NVIDIA API key in ~/.autohand/config.json.",
+  402: "Payment required. Please check your NVIDIA account balance or billing settings.",
+  403: "Access denied. Your API key may not have permission for this model.",
+  404: "The requested model was not found. Use /model to select a different one.",
+  429: "Rate limit exceeded. Please wait a moment and try again, or choose a different model.",
+  500: "The NVIDIA service encountered an internal error. Please try again later.",
+  502: "The NVIDIA service is temporarily unavailable. Please try again in a few moments.",
+  503: "The NVIDIA service is currently overloaded. Please try again later.",
+  504: "The request timed out. The service may be experiencing high load."
+};
+var NVIDIAClient = class {
+  
+  
+  
+  
+  
+  
+  constructor(settings, networkSettings) {
+    this.apiKey = _nullishCoalesce(settings.apiKey, () => ( ""));
+    this.baseUrl = _nullishCoalesce(settings.baseUrl, () => ( NVIDIA_DEFAULT_BASE_URL));
+    this.defaultModel = settings.model;
+    const configuredRetries = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _3 => _3.maxRetries]), () => ( DEFAULT_MAX_RETRIES));
+    this.maxRetries = Math.min(Math.max(0, configuredRetries), MAX_ALLOWED_RETRIES);
+    this.retryDelay = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _4 => _4.retryDelay]), () => ( DEFAULT_RETRY_DELAY));
+    this.timeout = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _5 => _5.timeout]), () => ( DEFAULT_TIMEOUT));
+  }
+  setDefaultModel(model) {
+    this.defaultModel = model;
+  }
+  async complete(request) {
+    const payload = this.buildPayload(request);
+    if (request.tools && request.tools.length > 0) {
+      payload.tools = request.tools.map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: _nullishCoalesce(tool.parameters, () => ( { type: "object", properties: {} }))
+        }
+      }));
+      if (request.toolChoice) {
+        payload.tool_choice = request.toolChoice;
+      }
+    }
+    if (request.chatTemplateKwargs) {
+      payload.extra_body = {
+        chat_template_kwargs: this.buildChatTemplateKwargs(request.chatTemplateKwargs)
+      };
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      "x-source": "Autohand Code CLI"
+    };
+    if (this.apiKey) {
+      headers.Authorization = `Bearer ${this.apiKey}`;
+    }
+    const payloadJson = JSON.stringify(payload);
+    const payloadSizeBytes = payloadJson.length;
+    const maxPayloadSize = 5 * 1024 * 1024;
+    if (payloadSizeBytes > maxPayloadSize) {
+      const sizeMB = (payloadSizeBytes / (1024 * 1024)).toFixed(2);
+      throw new Error(
+        `Request payload too large (${sizeMB}MB). This usually happens when the conversation history grows too long. Try using /undo to remove recent turns or /new to start fresh.`
+      );
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const response = await this.makeRequest(
+          payload,
+          headers,
+          request.signal,
+          payloadJson,
+          _nullishCoalesce(request.stream, () => ( false))
+        );
+        return response;
+      } catch (error) {
+        lastError = error;
+        if (this.isNonRetryableError(error)) {
+          throw error;
+        }
+        if (attempt < this.maxRetries) {
+          const delay = this.retryDelay * Math.pow(2, attempt);
+          await this.sleep(delay);
+        }
+      }
+    }
+    throw _nullishCoalesce(lastError, () => ( new Error("Failed to communicate with NVIDIA API. Please try again.")));
+  }
+  buildPayload(request) {
+    const payload = {
+      model: _nullishCoalesce(request.model, () => ( this.defaultModel)),
+      messages: sanitizeMessages(request.messages),
+      temperature: _nullishCoalesce(request.temperature, () => ( 0.2)),
+      max_tokens: _nullishCoalesce(request.maxTokens, () => ( 16e3)),
+      stream: _nullishCoalesce(request.stream, () => ( false))
+    };
+    return payload;
+  }
+  buildChatTemplateKwargs(kwargs) {
+    const result = {};
+    if (kwargs.thinking !== void 0) result.thinking = kwargs.thinking;
+    if (kwargs.enable_thinking !== void 0) result.enable_thinking = kwargs.enable_thinking;
+    if (kwargs.reasoning_effort !== void 0) result.reasoning_effort = kwargs.reasoning_effort;
+    if (kwargs.clear_thinking !== void 0) result.clear_thinking = kwargs.clear_thinking;
+    return result;
+  }
+  async makeRequest(payload, headers, signal, preSerializedBody, isStreaming = false) {
+    let response;
+    try {
+      const timeoutController = new AbortController();
+      const timeoutId = setTimeout(() => timeoutController.abort(), this.timeout);
+      const combinedSignal = signal ? this.combineSignals(signal, timeoutController.signal) : timeoutController.signal;
+      try {
+        response = await fetch(`${this.baseUrl}/chat/completions`, {
+          method: "POST",
+          headers,
+          body: _nullishCoalesce(preSerializedBody, () => ( JSON.stringify(payload))),
+          signal: combinedSignal
+        });
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch (error) {
+      const err = error;
+      if (err.name === "AbortError" && _optionalChain([signal, 'optionalAccess', _6 => _6.aborted])) {
+        throw new Error("Request cancelled.");
+      }
+      if (err.name === "AbortError") {
+        throw new Error("Request timed out. The NVIDIA service may be experiencing high load.");
+      }
+      throw new Error("Unable to connect to NVIDIA API. Please check your internet connection.");
+    }
+    if (!response.ok) {
+      throw await this.buildFriendlyError(response);
+    }
+    if (isStreaming) {
+      return this.handleStreamingResponse(response);
+    }
+    const json = await response.json();
+    const message = _optionalChain([json, 'optionalAccess', _7 => _7.choices, 'optionalAccess', _8 => _8[0], 'optionalAccess', _9 => _9.message]);
+    const text = _nullishCoalesce(_optionalChain([message, 'optionalAccess', _10 => _10.content]), () => ( ""));
+    const finishReason = _optionalChain([json, 'optionalAccess', _11 => _11.choices, 'optionalAccess', _12 => _12[0], 'optionalAccess', _13 => _13.finish_reason]);
+    let toolCalls;
+    if (_optionalChain([message, 'optionalAccess', _14 => _14.tool_calls]) && Array.isArray(message.tool_calls)) {
+      toolCalls = message.tool_calls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: {
+          name: _nullishCoalesce(_optionalChain([tc, 'access', _15 => _15.function, 'optionalAccess', _16 => _16.name]), () => ( "")),
+          arguments: _nullishCoalesce(_optionalChain([tc, 'access', _17 => _17.function, 'optionalAccess', _18 => _18.arguments]), () => ( "{}"))
+        }
+      }));
+    }
+    let usage;
+    if (_optionalChain([json, 'optionalAccess', _19 => _19.usage])) {
+      usage = {
+        promptTokens: _nullishCoalesce(json.usage.prompt_tokens, () => ( 0)),
+        completionTokens: _nullishCoalesce(json.usage.completion_tokens, () => ( 0)),
+        totalTokens: _nullishCoalesce(json.usage.total_tokens, () => ( 0))
+      };
+    }
+    return {
+      id: _nullishCoalesce(json.id, () => ( "nvidia-response")),
+      created: _nullishCoalesce(json.created, () => ( Date.now())),
+      content: text,
+      toolCalls,
+      finishReason,
+      usage,
+      raw: json
+    };
+  }
+  async handleStreamingResponse(response) {
+    const reader = _optionalChain([response, 'access', _20 => _20.body, 'optionalAccess', _21 => _21.getReader, 'call', _22 => _22()]);
+    if (!reader) {
+      throw new Error("No response body for streaming");
+    }
+    const decoder = new TextDecoder();
+    let fullContent = "";
+    let fullReasoning = "";
+    let lastChunk = null;
+    let finishReason = "stop";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = decoder.decode(value, { stream: true });
+        const lines = chunk.split("\n").filter((line) => line.trim());
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const dataStr = line.slice(6).trim();
+            if (dataStr === "[DONE]") continue;
+            try {
+              const data = JSON.parse(dataStr);
+              lastChunk = data;
+              const delta = _optionalChain([data, 'access', _23 => _23.choices, 'optionalAccess', _24 => _24[0], 'optionalAccess', _25 => _25.delta]);
+              if (!delta) continue;
+              const reasoning = delta.reasoning || delta.reasoning_content;
+              if (reasoning) {
+                fullReasoning += reasoning;
+              }
+              if (delta.content) {
+                fullContent += delta.content;
+              }
+              if (_optionalChain([data, 'access', _26 => _26.choices, 'optionalAccess', _27 => _27[0], 'optionalAccess', _28 => _28.finish_reason])) {
+                finishReason = data.choices[0].finish_reason;
+              }
+            } catch (e) {
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    const finalContent = fullReasoning ? `<thinking>${fullReasoning}</thinking>
+
+${fullContent}` : fullContent;
+    return {
+      id: _nullishCoalesce(_optionalChain([lastChunk, 'optionalAccess', _29 => _29.id]), () => ( `nvidia-stream-${Date.now()}`)),
+      created: _nullishCoalesce(_optionalChain([lastChunk, 'optionalAccess', _30 => _30.created]), () => ( Math.floor(Date.now() / 1e3))),
+      content: finalContent,
+      finishReason,
+      raw: { content: fullContent, reasoning: fullReasoning, chunks: lastChunk }
+    };
+  }
+  async buildFriendlyError(response) {
+    const status = response.status;
+    let errorDetail = "";
+    try {
+      const body = await response.json();
+      errorDetail = _optionalChain([body, 'optionalAccess', _31 => _31.error, 'optionalAccess', _32 => _32.message]) || _optionalChain([body, 'optionalAccess', _33 => _33.error]) || _optionalChain([body, 'optionalAccess', _34 => _34.message]) || "";
+      if (typeof errorDetail === "object") {
+        errorDetail = JSON.stringify(errorDetail);
+      }
+    } catch (e2) {
+      try {
+        errorDetail = await response.text();
+      } catch (e3) {
+      }
+    }
+    const friendlyMessage = FRIENDLY_ERRORS[status];
+    const classified = _chunk3OF56EMAcjs.classifyApiError.call(void 0, status, errorDetail, response.headers);
+    if (friendlyMessage) {
+      return new (0, _chunk3OF56EMAcjs.ApiError)(
+        errorDetail ? `${friendlyMessage}
+${errorDetail}` : friendlyMessage,
+        classified.code,
+        classified.httpStatus,
+        classified.retryable,
+        classified.retryAfterMs,
+        errorDetail
+      );
+    }
+    if (status >= 500) {
+      const base = "The NVIDIA service is temporarily unavailable. Please try again later.";
+      return new (0, _chunk3OF56EMAcjs.ApiError)(
+        errorDetail ? `${base}
+(${status}: ${errorDetail})` : base,
+        classified.code,
+        classified.httpStatus,
+        classified.retryable,
+        classified.retryAfterMs,
+        errorDetail
+      );
+    }
+    if (status >= 400) {
+      const base = "The request could not be processed.";
+      const message2 = errorDetail ? `${base} (${status}: ${errorDetail})` : `${base} (HTTP ${status}) Please try again or adjust your prompt.`;
+      return new (0, _chunk3OF56EMAcjs.ApiError)(
+        message2,
+        classified.code,
+        classified.httpStatus,
+        classified.retryable,
+        classified.retryAfterMs,
+        errorDetail
+      );
+    }
+    const message = errorDetail ? `An unexpected error occurred: ${errorDetail}` : "An unexpected error occurred. Please try again.";
+    return new (0, _chunk3OF56EMAcjs.ApiError)(
+      message,
+      classified.code,
+      classified.httpStatus,
+      classified.retryable,
+      classified.retryAfterMs,
+      errorDetail
+    );
+  }
+  isNonRetryableError(error) {
+    if (error instanceof _chunk3OF56EMAcjs.ApiError) {
+      return !error.retryable;
+    }
+    const message = error.message.toLowerCase();
+    if (message.includes("cancelled") || message.includes("aborted")) {
+      return true;
+    }
+    if (message.includes("authentication") || message.includes("api key")) {
+      return true;
+    }
+    if (message.includes("payment") || message.includes("access denied")) {
+      return true;
+    }
+    if (message.includes("not found")) {
+      return true;
+    }
+    return false;
+  }
+  combineSignals(signal1, signal2) {
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    signal1.addEventListener("abort", abort);
+    signal2.addEventListener("abort", abort);
+    if (signal1.aborted || signal2.aborted) {
+      controller.abort();
+    }
+    return controller.signal;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/providers/NVIDIAProvider.ts
+var NVIDIA_DEFAULT_BASE_URL2 = "https://integrate.api.nvidia.com/v1";
+var NVIDIA_MODELS = [
+  "deepseek-ai/deepseek-v4-pro",
+  "z-ai/glm-5.1",
+  "z-ai/glm-4.7",
+  "qwen/qwen3.5-122b-a10b",
+  "nvidia/usdcode",
+  "moonshotai/kimi-k2.5",
+  "minimaxai/minimax-m2.7",
+  "microsoft/phi-4-mini-instruct",
+  "mistralai/mistral-small-4-119b-2603",
+  "mistralai/mixtral-8x7b-instruct-v0.1",
+  "mistralai/mixtral-8x22b-instruct-v0.1",
+  "mistralai/mamba-codestral-7b-v0.1",
+  "nvidia/mistral-nemo-minitron-8b-base",
+  "google/gemma-4-31b-it",
+  "bigcode/starcoder2-7b"
+];
+var NVIDIA_DEFAULT_MODEL = "z-ai/glm-5.1";
+var NVIDIAProvider = class {
+  
+  
+  
+  
+  constructor(config, networkSettings) {
+    this.client = new NVIDIAClient(config, networkSettings);
+    this.model = config.model;
+    this.chatTemplateKwargs = config.chatTemplateKwargs;
+    this.stream = _nullishCoalesce(config.stream, () => ( false));
+  }
+  getName() {
+    return "nvidia";
+  }
+  setModel(model) {
+    this.model = model;
+    this.client.setDefaultModel(model);
+  }
+  async listModels() {
+    return [...NVIDIA_MODELS];
+  }
+  async isAvailable() {
+    return true;
+  }
+  async complete(request) {
+    const enhancedRequest = {
+      ...request,
+      // Use request stream if set, otherwise fall back to provider default
+      stream: _nullishCoalesce(request.stream, () => ( this.stream)),
+      // Merge chatTemplateKwargs: request-level takes precedence
+      chatTemplateKwargs: _nullishCoalesce(request.chatTemplateKwargs, () => ( this.chatTemplateKwargs))
+    };
+    return this.client.complete(enhancedRequest);
+  }
+};
+
+
+
+
+
+
+exports.NVIDIA_DEFAULT_BASE_URL = NVIDIA_DEFAULT_BASE_URL2; exports.NVIDIA_MODELS = NVIDIA_MODELS; exports.NVIDIA_DEFAULT_MODEL = NVIDIA_DEFAULT_MODEL; exports.NVIDIAProvider = NVIDIAProvider;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-Y72HH2TF.cjs → chunk-UXLW45ZE.cjs}

@@ -1,20 +1,83 @@
-"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; }
+"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 _chunkZYQMLKOKcjs = require('./chunk-ZYQMLKOK.cjs');
+var _chunkCH2J4PVEcjs = require('./chunk-CH2J4PVE.cjs');
 
 
-var _chunkSEKD5FH3cjs = require('./chunk-SEKD5FH3.cjs');
+var _chunkE26KKI46cjs = require('./chunk-E26KKI46.cjs');
 
 
-var _chunk7BTSG4MEcjs = require('./chunk-7BTSG4ME.cjs');
+var _chunkCHI52KFRcjs = require('./chunk-CHI52KFR.cjs');
 
 // src/commands/resume.ts
 var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
 var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
 var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+
+// src/session/chatLog.ts
+function decodeJsonStringLiteral(value) {
+  try {
+    return JSON.parse(`"${value}"`);
+  } catch (e) {
+    return value;
+  }
+}
+function extractJsonStringField(raw, field) {
+  const match = raw.match(new RegExp(`"${field}"\\s*:\\s*"((?:\\\\.|[^"\\\\])*)"`, "s"));
+  return _optionalChain([match, 'optionalAccess', _ => _[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 (e2) {
+    const finalResponse = _nullishCoalesce(extractJsonStringField(trimmed, "finalResponse"), () => ( extractJsonStringField(trimmed, "response")));
+    if (_optionalChain([finalResponse, 'optionalAccess', _2 => _2.trim, 'call', _3 => _3()])) {
+      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;
+}
+
+// src/commands/resume.ts
 var metadata = {
   command: "/resume",
-  description: _chunk7BTSG4MEcjs.t.call(void 0, "commands.resume.description"),
+  description: _chunkCHI52KFRcjs.t.call(void 0, "commands.resume.description"),
   implemented: true
 };
 async function getSessionTitle(sessionMeta) {
@@ -22,7 +85,7 @@ async function getSessionTitle(sessionMeta) {
     return sessionMeta.summary.slice(0, 60);
   }
   try {
-    const conversationPath = _path2.default.join(_chunkSEKD5FH3cjs.AUTOHAND_PATHS.sessions, sessionMeta.sessionId, "conversation.jsonl");
+    const conversationPath = _path2.default.join(_chunkE26KKI46cjs.AUTOHAND_PATHS.sessions, sessionMeta.sessionId, "conversation.jsonl");
     if (await _fsextra2.default.pathExists(conversationPath)) {
       const content = await _fsextra2.default.readFile(conversationPath, "utf-8");
       const lines = content.trim().split("\n").filter((line) => line);
@@ -33,11 +96,11 @@ async function getSessionTitle(sessionMeta) {
             const cleanContent = msg.content.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
             return cleanContent.slice(0, 60) + (cleanContent.length > 60 ? "..." : "");
           }
-        } catch (e) {
+        } catch (e3) {
         }
       }
     }
-  } catch (e2) {
+  } catch (e4) {
   }
   return _chalk2.default.gray("(no title)");
 }
@@ -66,7 +129,7 @@ function getTimeAgo(date) {
 async function resume(ctx) {
   const sessionId = ctx.args[0];
   if (sessionId) {
-    return resumeSession(ctx.sessionManager, sessionId);
+    return resumeSession(ctx.sessionManager, sessionId, ctx.restoreSession);
   }
   try {
     const projectFilter = ctx.workspaceRoot ? { project: ctx.workspaceRoot } : void 0;
@@ -79,13 +142,13 @@ No sessions found for project "${projectName}".`));
         console.log(_chalk2.default.gray("Use /sessions to see all sessions across projects.\n"));
       } else {
         console.log(_chalk2.default.gray(`
-${_chunk7BTSG4MEcjs.t.call(void 0, "commands.sessions.noSessions")}`));
+${_chunkCHI52KFRcjs.t.call(void 0, "commands.sessions.noSessions")}`));
         console.log(_chalk2.default.gray("Start a new conversation to create a session.\n"));
       }
       return null;
     }
     console.log(_chalk2.default.cyan(`
-${_chunk7BTSG4MEcjs.t.call(void 0, "commands.sessions.selectPrompt")}
+${_chunkCHI52KFRcjs.t.call(void 0, "commands.sessions.selectPrompt")}
 `));
     const choices = [];
     const recentSessions = allSessions.slice(0, 20);
@@ -105,10 +168,17 @@ ${_chunk7BTSG4MEcjs.t.call(void 0, "commands.sessions.selectPrompt")}
       value: choice.name,
       description: choice.hint
     }));
-    const result = await _chunkZYQMLKOKcjs.showModal.call(void 0, {
-      title: "Choose a session",
-      options
-    });
+    await _optionalChain([ctx, 'access', _4 => _4.onBeforeModal, 'optionalCall', _5 => _5()]);
+    const result = await (async () => {
+      try {
+        return await _chunkCH2J4PVEcjs.showModal.call(void 0, {
+          title: "Choose a session",
+          options
+        });
+      } finally {
+        await _optionalChain([ctx, 'access', _6 => _6.onAfterModal, 'optionalCall', _7 => _7()]);
+      }
+    })();
     if (!result) {
       console.log(_chalk2.default.gray("\nResume cancelled."));
       return null;
@@ -117,20 +187,20 @@ ${_chunk7BTSG4MEcjs.t.call(void 0, "commands.sessions.selectPrompt")}
       console.log(_chalk2.default.gray("\nUse /sessions to see all sessions, then /resume <id>"));
       return null;
     }
-    return resumeSession(ctx.sessionManager, result.value);
+    return resumeSession(ctx.sessionManager, result.value, ctx.restoreSession);
   } catch (error) {
-    console.error(_chalk2.default.red(_chunk7BTSG4MEcjs.t.call(void 0, "commands.resume.failed", { error: error.message })));
+    console.error(_chalk2.default.red(_chunkCHI52KFRcjs.t.call(void 0, "commands.resume.failed", { error: error.message })));
     return null;
   }
 }
-async function resumeSession(sessionManager, sessionId) {
+async function resumeSession(sessionManager, sessionId, restoreSession) {
   try {
     const session = await sessionManager.loadSession(sessionId);
     const messages = session.getMessages();
     const firstUserMessage = messages.find((m) => m.role === "user");
-    const title = session.metadata.summary || _optionalChain([firstUserMessage, 'optionalAccess', _ => _.content, 'access', _2 => _2.slice, 'call', _3 => _3(0, 50)]) || "Untitled session";
+    const title = session.metadata.summary || _optionalChain([firstUserMessage, 'optionalAccess', _8 => _8.content, 'access', _9 => _9.slice, 'call', _10 => _10(0, 50)]) || "Untitled session";
     console.log(_chalk2.default.cyan(`
-${_chunk7BTSG4MEcjs.t.call(void 0, "commands.resume.resuming", { id: title })}`));
+${_chunkCHI52KFRcjs.t.call(void 0, "commands.resume.resuming", { id: title })}`));
     console.log(_chalk2.default.gray(`   Project: ${session.metadata.projectPath}`));
     console.log(_chalk2.default.gray(`   Started: ${new Date(session.metadata.createdAt).toLocaleString()}`));
     console.log(_chalk2.default.gray(`   Messages: ${messages.length}`));
@@ -138,21 +208,19 @@ ${_chunk7BTSG4MEcjs.t.call(void 0, "commands.resume.resuming", { id: title })}`)
     if (messages.length > 0) {
       console.log(_chalk2.default.cyan("Recent conversation:"));
       console.log(_chalk2.default.gray("\u2500".repeat(60)));
-      const recentMessages = messages.slice(-5);
+      const recentMessages = buildSessionChatLog(messages).slice(-5);
       for (const msg of recentMessages) {
-        const role = msg.role === "user" ? _chalk2.default.green("You") : msg.role === "assistant" ? _chalk2.default.blue("Assistant") : _chalk2.default.gray(msg.role);
-        if (msg.role === "tool") continue;
-        const preview = msg.content.replace(/\n/g, " ").replace(/\s+/g, " ").slice(0, 100);
-        const truncated = msg.content.length > 100 ? "..." : "";
-        console.log(`${role}: ${_chalk2.default.white(preview)}${truncated}`);
+        const role = msg.role === "user" ? _chalk2.default.green("You") : _chalk2.default.blue("Assistant");
+        console.log(`${role}: ${_chalk2.default.white(formatChatLogPreview(msg.content))}`);
       }
       console.log(_chalk2.default.gray("\u2500".repeat(60)));
       console.log();
     }
+    await _optionalChain([restoreSession, 'optionalCall', _11 => _11(sessionId)]);
     console.log(_chalk2.default.green("Session resumed. Continue typing to chat.\n"));
     return null;
   } catch (error) {
-    console.error(_chalk2.default.red(_chunk7BTSG4MEcjs.t.call(void 0, "commands.resume.failed", { error: error.message })));
+    console.error(_chalk2.default.red(_chunkCHI52KFRcjs.t.call(void 0, "commands.resume.failed", { error: error.message })));
     return null;
   }
 }
@@ -160,7 +228,13 @@ ${_chunk7BTSG4MEcjs.t.call(void 0, "commands.resume.resuming", { id: title })}`)
 
 
 
-exports.metadata = metadata; exports.resume = resume;
+
+exports.buildSessionChatLog = buildSessionChatLog; exports.metadata = metadata; exports.resume = resume;
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
  * @license
  * Copyright 2025 Autohand AI LLC

package/dist/{chunk-FPHU2ES6.cjs → chunk-VBOFPU5M.cjs}

@@ -7,6 +7,12 @@ var DEFAULT_MAX_RETRIES = 3;
 var DEFAULT_RETRY_DELAY = 1e3;
 var MAX_FILES_PER_REQUEST = 100;
 var SyncApiClient = class {
+  
+  
+  
+  
+  
+  
   constructor(config) {
     this.baseUrl = _optionalChain([config, 'optionalAccess', _ => _.baseUrl]) || DEFAULT_BASE_URL;
     this.timeout = _optionalChain([config, 'optionalAccess', _2 => _2.timeout]) || DEFAULT_TIMEOUT;