autohand-cli 0.8.3 → 0.9.1

package/dist/chunk-5A7ZL64N.js

@@ -0,0 +1,139 @@
+import {
+  PROJECT_DIR_NAME
+} from "./chunk-SHRLFX6F.js";
+
+// src/permissions/localProjectPermissions.ts
+import fs from "fs-extra";
+import path from "path";
+var LOCAL_SETTINGS_FILE = "settings.local.json";
+function normalizePermissionSettings(settings) {
+  if (!settings) {
+    return settings;
+  }
+  const allowList = settings.allowList ?? settings.whitelist ?? [];
+  const denyList = settings.denyList ?? settings.blacklist ?? [];
+  return {
+    ...settings,
+    allowList,
+    denyList,
+    whitelist: void 0,
+    blacklist: void 0
+  };
+}
+function getLocalSettingsPath(workspaceRoot) {
+  return path.join(workspaceRoot, PROJECT_DIR_NAME, LOCAL_SETTINGS_FILE);
+}
+async function loadLocalProjectSettings(workspaceRoot) {
+  const settingsPath = getLocalSettingsPath(workspaceRoot);
+  try {
+    if (await fs.pathExists(settingsPath)) {
+      const content = await fs.readFile(settingsPath, "utf8");
+      const parsed = JSON.parse(content);
+      return {
+        ...parsed,
+        permissions: normalizePermissionSettings(parsed.permissions)
+      };
+    }
+  } catch (error) {
+    console.error(`Warning: Failed to parse local settings at ${settingsPath}:`, error.message);
+  }
+  return null;
+}
+async function saveLocalProjectSettings(workspaceRoot, settings) {
+  const settingsPath = getLocalSettingsPath(workspaceRoot);
+  const dir = path.dirname(settingsPath);
+  await fs.ensureDir(dir);
+  const toSave = {
+    ...settings,
+    version: 1
+  };
+  await fs.writeJson(settingsPath, toSave, { spaces: 2 });
+}
+async function addToLocalAllowList(workspaceRoot, pattern) {
+  const current = await loadLocalProjectSettings(workspaceRoot) || {};
+  const permissions = normalizePermissionSettings(current.permissions) || {};
+  const allowList = permissions.allowList || [];
+  if (!allowList.includes(pattern)) {
+    allowList.push(pattern);
+    await saveLocalProjectSettings(workspaceRoot, {
+      ...current,
+      permissions: {
+        ...permissions,
+        allowList
+      }
+    });
+  }
+}
+async function addToLocalDenyList(workspaceRoot, pattern) {
+  const current = await loadLocalProjectSettings(workspaceRoot) || {};
+  const permissions = normalizePermissionSettings(current.permissions) || {};
+  const denyList = permissions.denyList || [];
+  if (!denyList.includes(pattern)) {
+    denyList.push(pattern);
+    await saveLocalProjectSettings(workspaceRoot, {
+      ...current,
+      permissions: {
+        ...permissions,
+        denyList
+      }
+    });
+  }
+}
+function mergePermissions(globalSettings, localSettings) {
+  const normalizedGlobal = normalizePermissionSettings(globalSettings) ?? {};
+  const normalizedLocal = normalizePermissionSettings(localSettings);
+  if (!normalizedLocal) {
+    return normalizedGlobal;
+  }
+  return {
+    // Global settings as base
+    ...normalizedGlobal,
+    // Local mode overrides global if set
+    mode: normalizedLocal.mode || normalizedGlobal.mode,
+    allowList: [
+      ...normalizedGlobal.allowList || [],
+      ...normalizedLocal.allowList || []
+    ].filter((v, i, a) => a.indexOf(v) === i),
+    denyList: [
+      ...normalizedGlobal.denyList || [],
+      ...normalizedLocal.denyList || []
+    ].filter((v, i, a) => a.indexOf(v) === i),
+    // Merge rules (local rules checked first)
+    rules: [
+      ...normalizedLocal.rules || [],
+      ...normalizedGlobal.rules || []
+    ],
+    // Use local rememberSession if set, otherwise global
+    rememberSession: normalizedLocal.rememberSession ?? normalizedGlobal.rememberSession,
+    allowPatterns: [
+      ...normalizedGlobal.allowPatterns || [],
+      ...normalizedLocal.allowPatterns || []
+    ],
+    denyPatterns: [
+      ...normalizedGlobal.denyPatterns || [],
+      ...normalizedLocal.denyPatterns || []
+    ],
+    availableTools: [
+      ...normalizedGlobal.availableTools || [],
+      ...normalizedLocal.availableTools || []
+    ],
+    excludedTools: [
+      ...normalizedGlobal.excludedTools || [],
+      ...normalizedLocal.excludedTools || []
+    ],
+    allPathsAllowed: normalizedLocal.allPathsAllowed ?? normalizedGlobal.allPathsAllowed,
+    allUrlsAllowed: normalizedLocal.allUrlsAllowed ?? normalizedGlobal.allUrlsAllowed
+  };
+}
+
+export {
+  loadLocalProjectSettings,
+  addToLocalAllowList,
+  addToLocalDenyList,
+  mergePermissions
+};
+/**
+ * Local Project Permissions
+ * Handles per-project permission settings stored in .autohand/settings.local.json
+ * @license Apache-2.0
+ */

package/dist/chunk-5GCQ5UMV.cjs

@@ -0,0 +1,85 @@
+"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 _chunkYISPVAXOcjs = require('./chunk-YISPVAXO.cjs');
+
+
+
+
+var _chunkX5P6QQOBcjs = require('./chunk-X5P6QQOB.cjs');
+
+
+
+
+var _chunkSY2P3Z5Wcjs = require('./chunk-SY2P3Z5W.cjs');
+
+// src/commands/setup.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var metadata = {
+  command: "/setup",
+  description: _nullishCoalesce(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.setup.description"), () => ( "Run the setup wizard to configure or reconfigure Autohand")),
+  implemented: true
+};
+async function setup(ctx) {
+  if (ctx.isNonInteractive) {
+    return _nullishCoalesce(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.setup.interactiveOnly"), () => ( "Setup requires an interactive terminal. Use the --setup CLI flag instead."));
+  }
+  const { locale: detectedLocale } = _chunkSY2P3Z5Wcjs.detectLocale.call(void 0, );
+  const locale = _nullishCoalesce(detectedLocale, () => ( "en"));
+  await _chunkSY2P3Z5Wcjs.initI18n.call(void 0, locale);
+  const config = await _chunkX5P6QQOBcjs.loadConfig.call(void 0, _optionalChain([ctx, 'access', _ => _.config, 'optionalAccess', _2 => _2.configPath]), ctx.workspaceRoot);
+  const workspaceRoot = _chunkX5P6QQOBcjs.resolveWorkspaceRoot.call(void 0, config, ctx.workspaceRoot);
+  if (ctx.eventEmitter) {
+    ctx.eventEmitter.emit("setup:started", {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      locale,
+      workspaceRoot
+    });
+  }
+  const wizard = new (0, _chunkYISPVAXOcjs.SetupWizard)(workspaceRoot, config);
+  const result = await wizard.run({ force: true, skipWelcome: false });
+  if (result.cancelled) {
+    if (ctx.eventEmitter) {
+      ctx.eventEmitter.emit("setup:cancelled", {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        step: "user_cancelled"
+      });
+    }
+    return _nullishCoalesce(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.setup.cancelled"), () => ( "Setup cancelled."));
+  }
+  if (!result.success) {
+    if (ctx.eventEmitter) {
+      ctx.eventEmitter.emit("setup:error", {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        error: "setup_failed"
+      });
+    }
+    return _nullishCoalesce(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.setup.failed"), () => ( "Setup failed. Please try again."));
+  }
+  const newConfig = { ...config, ...result.config };
+  await _chunkX5P6QQOBcjs.saveConfig.call(void 0, newConfig);
+  if (ctx.eventEmitter) {
+    const provider = result.config.provider;
+    const providerConfig = provider && result.config[provider];
+    const model = providerConfig && typeof providerConfig === "object" && "model" in providerConfig ? providerConfig.model : void 0;
+    ctx.eventEmitter.emit("setup:complete", {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      success: true,
+      provider,
+      model,
+      skippedSteps: result.skippedSteps,
+      agentsFileCreated: result.agentsFileCreated
+    });
+  }
+  console.log(_chalk2.default.green(_nullishCoalesce(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.setup.complete"), () => ( "\nSetup complete!"))));
+  return null;
+}
+
+
+
+
+exports.metadata = metadata; exports.setup = setup;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-5JTTM5SC.js

@@ -0,0 +1,59 @@
+// src/commands/review.ts
+import chalk from "chalk";
+import path from "path";
+import fse from "fs-extra";
+var metadata = {
+  command: "/review",
+  description: "staff-level code review with 10 actionable findings",
+  implemented: true
+};
+async function review(ctx, args = []) {
+  const userInstructions = args.join(" ").trim();
+  const skillPath = path.resolve(
+    path.dirname(new URL(import.meta.url).pathname),
+    "../skills/builtin/code-reviewer/SKILL.md"
+  );
+  let skillBody = "";
+  try {
+    const content = await fse.readFile(skillPath, "utf-8");
+    const bodyMatch = content.match(/^---[\s\S]*?---\s*([\s\S]*)$/);
+    skillBody = bodyMatch ? bodyMatch[1].trim() : content;
+  } catch {
+    skillBody = "Perform a thorough code review analyzing architecture, security, performance, error handling, and maintainability.";
+  }
+  const parts = [
+    skillBody,
+    "",
+    "## Review Target",
+    `Workspace: ${ctx.workspaceRoot}`
+  ];
+  if (userInstructions) {
+    parts.push("", "## Additional Focus", userInstructions);
+  }
+  parts.push(
+    "",
+    "## Instructions",
+    "Start the review now. Use the available tools (read_file, fff_grep, fff_find, list_tree, git_status, git_diff) to gather context, then deliver your 10-dimension review."
+  );
+  const prompt = parts.join("\n");
+  if (ctx.isNonInteractive || !ctx.queueInstruction) {
+    return prompt;
+  }
+  ctx.queueInstruction(prompt);
+  console.log(chalk.cyan("\n  Starting code review..."));
+  if (userInstructions) {
+    console.log(chalk.gray(`  Focus: ${userInstructions}`));
+  }
+  console.log(chalk.gray("  Analyzing 10 dimensions: architecture, security, performance, and more.\n"));
+  return null;
+}
+
+export {
+  metadata,
+  review
+};
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-IETRBBMP.cjs → chunk-5K3CDSWZ.cjs}

@@ -1,12 +1,74 @@
-"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(); } }
+"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(); } } var _class;
 
-var _chunkLJFUXC56cjs = require('./chunk-LJFUXC56.cjs');
+var _chunkHXQREVTAcjs = require('./chunk-HXQREVTA.cjs');
+
+
+var _chunkXF2WIKHRcjs = require('./chunk-XF2WIKHR.cjs');
 
 // src/actions/filesystem.ts
 var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
 var _path = require('path'); var _path2 = _interopRequireDefault(_path);
 var _child_process = require('child_process');
 var _diff = require('diff');
+
+// src/utils/patchValidator.ts
+function validateAndFixPatch(patch) {
+  const lines = patch.split("\n");
+  const result = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+    if (hunkMatch) {
+      i++;
+      const hunkLines = [];
+      while (i < lines.length) {
+        const nextLine = lines[i];
+        if (nextLine.match(/^@@ /) || nextLine.match(/^(---|\+\+\+|Index:|diff\s)/) || nextLine === "===================================================================") {
+          break;
+        }
+        hunkLines.push(nextLine);
+        i++;
+      }
+      let oldCount = 0;
+      let newCount = 0;
+      for (const hunkLine of hunkLines) {
+        if (hunkLine.length === 0) continue;
+        const firstChar = hunkLine[0];
+        if (firstChar === "-") {
+          oldCount++;
+        } else if (firstChar === "+") {
+          newCount++;
+        } else if (firstChar === " " || firstChar === "	") {
+          oldCount++;
+          newCount++;
+        } else if (firstChar === "\\") {
+        } else {
+          oldCount++;
+          newCount++;
+        }
+      }
+      const oldStart = hunkMatch[1];
+      const newStart = hunkMatch[3];
+      let correctedHeader;
+      if (oldCount === 0) {
+        correctedHeader = `@@ -${parseInt(oldStart) + 1} +${newStart},${newCount} @@`;
+      } else if (newCount === 0) {
+        correctedHeader = `@@ -${oldStart},${oldCount} +${parseInt(newStart) + 1} @@`;
+      } else {
+        correctedHeader = `@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`;
+      }
+      result.push(correctedHeader);
+      result.push(...hunkLines);
+    } else {
+      result.push(line);
+      i++;
+    }
+  }
+  return result.join("\n");
+}
+
+// src/actions/filesystem.ts
 var FILE_LIMITS = {
   /** Maximum file size for read operations (10MB) */
   MAX_READ_SIZE: 10 * 1024 * 1024,
@@ -19,17 +81,19 @@ var FILE_LIMITS = {
   /** Maximum undo stack size */
   MAX_UNDO_STACK: 100
 };
-var FileActionManager = class {
-  constructor(workspaceRoot, additionalDirs = []) {
-    this.undoStack = [];
-    // Preview mode state
-    this.previewMode = false;
-    this.pendingChanges = [];
-    this.batchId = null;
-    this.changeCounter = 0;
-    this.onBatchChange = null;
-    this.currentToolId = "";
-    this.currentToolName = "";
+var FileActionManager = (_class = class {
+  __init() {this.undoStack = []}
+  
+  
+  // Preview mode state
+  __init2() {this.previewMode = false}
+  __init3() {this.pendingChanges = []}
+  __init4() {this.batchId = null}
+  __init5() {this.changeCounter = 0}
+  __init6() {this.onBatchChange = null}
+  __init7() {this.currentToolId = ""}
+  __init8() {this.currentToolName = ""}
+  constructor(workspaceRoot, additionalDirs = []) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);
     const resolvedRoot = _path2.default.resolve(workspaceRoot);
     try {
       this.workspaceRoot = _fsextra2.default.realpathSync(resolvedRoot);
@@ -186,6 +250,14 @@ var FileActionManager = class {
   get root() {
     return this.workspaceRoot;
   }
+  setWorkspaceRoot(workspaceRoot) {
+    const resolvedRoot = _path2.default.resolve(workspaceRoot);
+    try {
+      this.workspaceRoot = _fsextra2.default.realpathSync(resolvedRoot);
+    } catch (e4) {
+      this.workspaceRoot = resolvedRoot;
+    }
+  }
   async readFile(target) {
     const filePath = this.resolvePath(target);
     const exists = await _fsextra2.default.pathExists(filePath);
@@ -235,7 +307,8 @@ var FileActionManager = class {
   async applyPatch(target, patch, description) {
     const filePath = this.resolvePath(target);
     const current = await this.readFileSafe(target);
-    const updated = _diff.applyPatch.call(void 0, current, patch);
+    const fixedPatch = validateAndFixPatch(patch);
+    const updated = _diff.applyPatch.call(void 0, current, fixedPatch);
     if (updated === false) {
       throw new Error(`Failed to apply patch to ${target}`);
     }
@@ -261,7 +334,7 @@ var FileActionManager = class {
   }
   search(query, relativePath) {
     const searchDir = this.resolvePath(_nullishCoalesce(relativePath, () => ( ".")));
-    const rgResult = _child_process.spawnSync.call(void 0, "rg", [
+    const rgResult = _child_process.spawnSync.call(void 0, _chunkXF2WIKHRcjs.resolveRipgrepCommand.call(void 0, ), [
       "--line-number",
       "--color",
       "never",
@@ -321,7 +394,7 @@ var FileActionManager = class {
     const limit = _nullishCoalesce(opts.limit, () => ( 5));
     const window = _nullishCoalesce(opts.window, () => ( 400));
     const baseDir = this.resolvePath(_nullishCoalesce(opts.relativePath, () => ( ".")));
-    const ignoreFilter = new (0, _chunkLJFUXC56cjs.GitIgnoreParser)(baseDir);
+    const ignoreFilter = new (0, _chunkHXQREVTAcjs.GitIgnoreParser)(baseDir);
     const results = [];
     const stack = [baseDir];
     const lowerQuery = query.toLowerCase();
@@ -421,7 +494,7 @@ var FileActionManager = class {
           file: normalizedRel || _path2.default.basename(current),
           snippet
         });
-      } catch (e4) {
+      } catch (e5) {
         continue;
       }
     }
@@ -443,24 +516,13 @@ var FileActionManager = class {
   resolvePath(target) {
     const normalized = _path2.default.isAbsolute(target) ? target : _path2.default.join(this.workspaceRoot, target);
     const resolved = _path2.default.resolve(normalized);
-    let realPath;
-    try {
-      realPath = _fsextra2.default.realpathSync(resolved);
-    } catch (e5) {
-      const parentDir = _path2.default.dirname(resolved);
-      try {
-        const realParent = _fsextra2.default.realpathSync(parentDir);
-        realPath = _path2.default.join(realParent, _path2.default.basename(resolved));
-      } catch (e6) {
-        realPath = resolved;
-      }
-    }
+    const realPath = this.resolveRealPathOrAncestor(resolved);
     const allAllowedRoots = [this.workspaceRoot, ...this.additionalDirs];
     for (const allowedRoot of allAllowedRoots) {
       let realRoot;
       try {
         realRoot = _fsextra2.default.realpathSync(allowedRoot);
-      } catch (e7) {
+      } catch (e6) {
         realRoot = allowedRoot;
       }
       const rootWithSep = realRoot.endsWith(_path2.default.sep) ? realRoot : `${realRoot}${_path2.default.sep}`;
@@ -471,6 +533,21 @@ var FileActionManager = class {
     const allowedDirsList = allAllowedRoots.join(", ");
     throw new Error(`Path ${target} escapes the allowed directories: ${allowedDirsList}`);
   }
+  resolveRealPathOrAncestor(resolvedPath) {
+    let probe = resolvedPath;
+    while (true) {
+      try {
+        const realProbe = _fsextra2.default.realpathSync(probe);
+        return probe === resolvedPath ? realProbe : _path2.default.join(realProbe, _path2.default.relative(probe, resolvedPath));
+      } catch (e7) {
+        const parent = _path2.default.dirname(probe);
+        if (parent === probe) {
+          return resolvedPath;
+        }
+        probe = parent;
+      }
+    }
+  }
   walkFallback(query, baseDir) {
     const hits = [];
     const stack = [baseDir];
@@ -590,7 +667,7 @@ var FileActionManager = class {
     return `${hit.file}:${hit.line}
 ${snippet.join("\n")}`;
   }
-};
+}, _class);
 
 
 

package/dist/{chunk-KLWJIPU2.cjs → chunk-5SFV2NCY.cjs}

@@ -1,21 +1,21 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
-var _chunkY45G6ZO5cjs = require('./chunk-Y45G6ZO5.cjs');
+var _chunkCO2AADYUcjs = require('./chunk-CO2AADYU.cjs');
 
 
-var _chunkOLSBBZW6cjs = require('./chunk-OLSBBZW6.cjs');
+var _chunkCK4HAHVYcjs = require('./chunk-CK4HAHVY.cjs');
 
 
-var _chunkCB4E2T5Ncjs = require('./chunk-CB4E2T5N.cjs');
+var _chunkX5P6QQOBcjs = require('./chunk-X5P6QQOB.cjs');
 
 
-var _chunk7BTSG4MEcjs = require('./chunk-7BTSG4ME.cjs');
+var _chunkSY2P3Z5Wcjs = require('./chunk-SY2P3Z5W.cjs');
 
 // src/commands/logout.ts
 var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
 var metadata = {
   command: "/logout",
-  description: _chunk7BTSG4MEcjs.t.call(void 0, "commands.logout.description"),
+  description: _chunkSY2P3Z5Wcjs.t.call(void 0, "commands.logout.description"),
   implemented: true
 };
 async function logout(ctx) {
@@ -26,31 +26,35 @@ async function logout(ctx) {
     return null;
   }
   const userName = _optionalChain([config, 'access', _3 => _3.auth, 'access', _4 => _4.user, 'optionalAccess', _5 => _5.name]) || _optionalChain([config, 'access', _6 => _6.auth, 'access', _7 => _7.user, 'optionalAccess', _8 => _8.email]) || "user";
-  const result = await _chunkOLSBBZW6cjs.safePrompt.call(void 0, {
-    type: "confirm",
-    name: "confirm",
-    message: `Log out from ${_chalk2.default.cyan(userName)}?`,
-    initial: true
+  const selected = await _chunkCK4HAHVYcjs.showModal.call(void 0, {
+    title: `Log out from ${_chalk2.default.cyan(userName)}?`,
+    options: [
+      { label: "Yes", value: "yes" },
+      { label: "No", value: "no" }
+    ]
   });
-  if (!result || !result.confirm) {
-    console.log(_chalk2.default.gray(_chunk7BTSG4MEcjs.t.call(void 0, "commands.logout.cancelled")));
+  if (!selected || selected.value === "no") {
+    console.log(_chalk2.default.gray(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.logout.cancelled")));
     return null;
   }
-  const authClient = _chunkY45G6ZO5cjs.getAuthClient.call(void 0, );
+  const authClient = _chunkCO2AADYUcjs.getAuthClient.call(void 0, );
   try {
     await authClient.logout(config.auth.token);
   } catch (e) {
   }
+  if (ctx.currentSession) {
+    await ctx.currentSession.save();
+  }
   const updatedConfig = {
     ...config,
     auth: void 0
   };
-  await _chunkCB4E2T5Ncjs.saveConfig.call(void 0, updatedConfig);
+  await _chunkX5P6QQOBcjs.saveConfig.call(void 0, updatedConfig);
   console.log();
-  console.log(_chalk2.default.green(_chunk7BTSG4MEcjs.t.call(void 0, "commands.logout.success")));
+  console.log(_chalk2.default.green(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.logout.success")));
   console.log(_chalk2.default.gray("Your local session has been cleared."));
   console.log();
-  return null;
+  process.exit(0);
 }
 
 

package/dist/chunk-5ZNYX4VH.cjs

@@ -0,0 +1,71 @@
+"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; }// 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;
+}
+
+
+
+
+
+exports.getAssistantChatLogContent = getAssistantChatLogContent; exports.buildSessionChatLog = buildSessionChatLog; exports.formatChatLogPreview = formatChatLogPreview;
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */