autohand-cli 0.6.12 → 0.7.2

package/dist/chunk-UOLJZFPJ.js

@@ -0,0 +1,497 @@
+// src/core/HookManager.ts
+import { spawn } from "child_process";
+import { minimatch } from "minimatch";
+var DEFAULT_HOOK_TIMEOUT = 5e3;
+var HookManager = class {
+  constructor(options) {
+    this.initialized = false;
+    this.settings = options.settings ?? { enabled: true, hooks: [] };
+    this.workspaceRoot = options.workspaceRoot;
+    this.onPersist = options.onPersist;
+    this.onHookOutput = options.onHookOutput;
+  }
+  /**
+   * Initialize hooks - set up default hooks if none exist
+   */
+  async initialize() {
+    if (this.initialized) return;
+    this.initialized = true;
+    if (!this.settings.hooks || this.settings.hooks.length === 0) {
+      await this.installDefaultHooks();
+    } else {
+      await this.mergeDefaultHooks();
+    }
+    await this.ensureHookScripts();
+  }
+  /**
+   * Install default hooks (disabled by default)
+   */
+  async installDefaultHooks() {
+    try {
+      const { DEFAULT_HOOKS, SMART_COMMIT_HOOK } = await import("./defaultHooks-3GRSZNKA.js");
+      this.settings.hooks = [...DEFAULT_HOOKS, SMART_COMMIT_HOOK];
+      if (this.onPersist) {
+        await this.onPersist();
+      }
+    } catch {
+    }
+  }
+  /**
+   * Get a unique identifier for a hook (used for deduplication)
+   * Uses script filename for script-based hooks, or event+description for inline commands
+   */
+  getHookIdentifier(hook) {
+    const scriptMatch = hook.command.match(/([^/]+\.sh)$/);
+    if (scriptMatch) {
+      return `script:${scriptMatch[1]}`;
+    }
+    if (hook.description) {
+      return `${hook.event}:${hook.description}`;
+    }
+    return `${hook.event}:${hook.command}`;
+  }
+  /**
+   * Merge any missing default hooks with existing user hooks
+   * This ensures new built-in hooks are added when upgrading
+   */
+  async mergeDefaultHooks() {
+    try {
+      const { DEFAULT_HOOKS, SMART_COMMIT_HOOK } = await import("./defaultHooks-3GRSZNKA.js");
+      const allDefaults = [...DEFAULT_HOOKS, SMART_COMMIT_HOOK];
+      const existingHooks = this.settings.hooks ?? [];
+      const existingIds = new Set(existingHooks.map((h) => this.getHookIdentifier(h)));
+      const missingHooks = allDefaults.filter((h) => !existingIds.has(this.getHookIdentifier(h)));
+      if (missingHooks.length > 0) {
+        this.settings.hooks = [...existingHooks, ...missingHooks];
+        if (this.onPersist) {
+          await this.onPersist();
+        }
+      }
+    } catch (error) {
+      console.error("[hooks] Failed to merge default hooks:", error);
+    }
+  }
+  /**
+   * Ensure all hook scripts exist in ~/.autohand/hooks/
+   * Installs bundled scripts for built-in hooks
+   */
+  async ensureHookScripts() {
+    try {
+      const fs = await import("fs-extra");
+      const path = await import("path");
+      const os = await import("os");
+      const hooksDir = path.join(os.homedir(), ".autohand", "hooks");
+      await fs.ensureDir(hooksDir);
+      const { HOOK_SCRIPTS } = await import("./defaultHooks-3GRSZNKA.js");
+      for (const [scriptName, scriptContent] of Object.entries(HOOK_SCRIPTS)) {
+        const scriptPath = path.join(hooksDir, scriptName);
+        if (!await fs.pathExists(scriptPath)) {
+          await fs.writeFile(scriptPath, scriptContent, { mode: 493 });
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Check if hooks are globally enabled
+   */
+  isEnabled() {
+    return this.settings.enabled !== false;
+  }
+  /**
+   * Get all registered hooks
+   */
+  getHooks() {
+    return this.settings.hooks ?? [];
+  }
+  /**
+   * Get current settings
+   */
+  getSettings() {
+    return { ...this.settings };
+  }
+  /**
+   * Update settings
+   */
+  async updateSettings(settings) {
+    this.settings = { ...this.settings, ...settings };
+    if (this.onPersist) {
+      await this.onPersist();
+    }
+  }
+  /**
+   * Add a new hook
+   */
+  async addHook(hook) {
+    const hooks = this.settings.hooks ?? [];
+    hooks.push({ ...hook, enabled: hook.enabled !== false });
+    this.settings.hooks = hooks;
+    if (this.onPersist) {
+      await this.onPersist();
+    }
+  }
+  /**
+   * Remove a hook by index within its event type
+   */
+  async removeHook(event, index) {
+    const hooks = this.settings.hooks ?? [];
+    const eventHooks = hooks.filter((h) => h.event === event);
+    if (index < 0 || index >= eventHooks.length) {
+      return false;
+    }
+    const hookToRemove = eventHooks[index];
+    const globalIndex = hooks.indexOf(hookToRemove);
+    if (globalIndex !== -1) {
+      hooks.splice(globalIndex, 1);
+      this.settings.hooks = hooks;
+      if (this.onPersist) {
+        await this.onPersist();
+      }
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Toggle a hook's enabled status
+   */
+  async toggleHook(event, index) {
+    const hooks = this.settings.hooks ?? [];
+    const eventHooks = hooks.filter((h) => h.event === event);
+    if (index < 0 || index >= eventHooks.length) {
+      return false;
+    }
+    const hook = eventHooks[index];
+    hook.enabled = hook.enabled === false;
+    if (this.onPersist) {
+      await this.onPersist();
+    }
+    return true;
+  }
+  /**
+   * Check if a hook's filter matches the context
+   */
+  matchesFilter(filter, context) {
+    if (!filter) return true;
+    if (filter.tool && filter.tool.length > 0) {
+      if (!context.tool || !filter.tool.includes(context.tool)) {
+        return false;
+      }
+    }
+    if (filter.path && filter.path.length > 0) {
+      if (!context.path) return false;
+      const matches = filter.path.some((pattern) => minimatch(context.path, pattern));
+      if (!matches) return false;
+    }
+    return true;
+  }
+  /**
+   * Check if a hook's regex matcher matches the context
+   * Matchers apply to tool names, notification types, session types, etc.
+   */
+  matchesMatcher(hook, context) {
+    if (!hook.matcher) return true;
+    let value = "";
+    switch (hook.event) {
+      case "pre-tool":
+      case "post-tool":
+      case "permission-request":
+        value = context.tool ?? "";
+        break;
+      case "notification":
+        value = context.notificationType ?? "";
+        break;
+      case "session-start":
+        value = context.sessionType ?? "";
+        break;
+      case "session-end":
+        value = context.sessionEndReason ?? "";
+        break;
+      case "subagent-stop":
+        value = context.subagentType ?? "";
+        break;
+      default:
+        return true;
+    }
+    try {
+      return new RegExp(hook.matcher).test(value);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Build environment variables from hook context
+   */
+  buildEnvironment(context) {
+    const env = {
+      ...process.env,
+      HOOK_EVENT: context.event,
+      HOOK_WORKSPACE: context.workspace
+    };
+    if (context.sessionId) env.HOOK_SESSION_ID = context.sessionId;
+    if (context.tool) env.HOOK_TOOL = context.tool;
+    if (context.toolCallId) env.HOOK_TOOL_CALL_ID = context.toolCallId;
+    if (context.args) env.HOOK_ARGS = JSON.stringify(context.args);
+    if (context.success !== void 0) env.HOOK_SUCCESS = String(context.success);
+    if (context.output) env.HOOK_OUTPUT = context.output;
+    if (context.duration !== void 0) env.HOOK_DURATION = String(context.duration);
+    if (context.path) env.HOOK_PATH = context.path;
+    if (context.changeType) env.HOOK_CHANGE_TYPE = context.changeType;
+    if (context.instruction) env.HOOK_INSTRUCTION = context.instruction;
+    if (context.mentionedFiles) env.HOOK_MENTIONED_FILES = JSON.stringify(context.mentionedFiles);
+    if (context.tokensUsed !== void 0) env.HOOK_TOKENS = String(context.tokensUsed);
+    if (context.toolCallsCount !== void 0) env.HOOK_TOOL_CALLS_COUNT = String(context.toolCallsCount);
+    if (context.toolCallsInTurn !== void 0) env.HOOK_TURN_TOOL_CALLS = String(context.toolCallsInTurn);
+    if (context.turnDuration !== void 0) env.HOOK_TURN_DURATION = String(context.turnDuration);
+    if (context.error) env.HOOK_ERROR = context.error;
+    if (context.errorCode) env.HOOK_ERROR_CODE = context.errorCode;
+    if (context.sessionType) env.HOOK_SESSION_TYPE = context.sessionType;
+    if (context.sessionEndReason) env.HOOK_SESSION_END_REASON = context.sessionEndReason;
+    if (context.subagentId) env.HOOK_SUBAGENT_ID = context.subagentId;
+    if (context.subagentType) env.HOOK_SUBAGENT_TYPE = context.subagentType;
+    if (context.permissionType) env.HOOK_PERMISSION_TYPE = context.permissionType;
+    if (context.notificationType) env.HOOK_NOTIFICATION_TYPE = context.notificationType;
+    if (context.notificationMessage) env.HOOK_NOTIFICATION_MSG = context.notificationMessage;
+    return env;
+  }
+  /**
+   * Build JSON input to pass via stdin to hook
+   */
+  buildJsonInput(context) {
+    return JSON.stringify({
+      session_id: context.sessionId,
+      cwd: context.workspace,
+      hook_event_name: context.event,
+      // Tool context
+      tool_name: context.tool,
+      tool_input: context.args,
+      tool_use_id: context.toolCallId,
+      tool_response: context.output,
+      tool_success: context.success,
+      // File context
+      file_path: context.path,
+      change_type: context.changeType,
+      // Prompt context
+      instruction: context.instruction,
+      mentioned_files: context.mentionedFiles,
+      // Stop/response context
+      tokens_used: context.tokensUsed,
+      tool_calls_count: context.toolCallsCount,
+      turn_tool_calls: context.toolCallsInTurn,
+      turn_duration: context.turnDuration,
+      duration: context.duration,
+      // Error context
+      error: context.error,
+      error_code: context.errorCode,
+      // Session context
+      session_type: context.sessionType,
+      session_end_reason: context.sessionEndReason,
+      // Subagent context
+      subagent_id: context.subagentId,
+      subagent_name: context.subagentName,
+      subagent_type: context.subagentType,
+      subagent_success: context.subagentSuccess,
+      subagent_error: context.subagentError,
+      subagent_duration: context.subagentDuration,
+      // Permission context
+      permission_type: context.permissionType,
+      // Notification context
+      notification_type: context.notificationType,
+      notification_message: context.notificationMessage
+    });
+  }
+  /**
+   * Parse JSON response from hook stdout
+   */
+  parseHookResponse(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed.startsWith("{")) {
+      return void 0;
+    }
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Execute a single hook
+   */
+  async executeHook(hook, context) {
+    const startTime = Date.now();
+    const timeout = hook.timeout ?? DEFAULT_HOOK_TIMEOUT;
+    const env = this.buildEnvironment(context);
+    const jsonInput = this.buildJsonInput(context);
+    return new Promise((resolve) => {
+      const child = spawn(hook.command, [], {
+        shell: true,
+        cwd: this.workspaceRoot,
+        env,
+        stdio: ["pipe", "pipe", "pipe"]
+        // stdin enabled for JSON input
+      });
+      let stdout = "";
+      let stderr = "";
+      let killed = false;
+      const timeoutId = setTimeout(() => {
+        killed = true;
+        child.kill("SIGTERM");
+        setTimeout(() => child.kill("SIGKILL"), 1e3);
+      }, timeout);
+      child.stdin?.write(jsonInput);
+      child.stdin?.end();
+      child.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.on("close", (code) => {
+        clearTimeout(timeoutId);
+        const duration = Date.now() - startTime;
+        const exitCode = code ?? 0;
+        const isBlockingError = exitCode === 2;
+        let response;
+        if (exitCode === 0) {
+          response = this.parseHookResponse(stdout);
+        }
+        const result = {
+          hook,
+          success: !killed && exitCode === 0,
+          stdout: stdout.trim() || void 0,
+          stderr: stderr.trim() || void 0,
+          error: killed ? `Hook timed out after ${timeout}ms` : isBlockingError ? stderr.trim() || "Hook blocked execution" : void 0,
+          duration,
+          exitCode,
+          blockingError: isBlockingError,
+          response
+        };
+        if (this.onHookOutput) {
+          this.onHookOutput(result);
+        }
+        resolve(result);
+      });
+      child.on("error", (err) => {
+        clearTimeout(timeoutId);
+        const duration = Date.now() - startTime;
+        const result = {
+          hook,
+          success: false,
+          error: err.message,
+          duration,
+          exitCode: -1
+        };
+        if (this.onHookOutput) {
+          this.onHookOutput(result);
+        }
+        resolve(result);
+      });
+    });
+  }
+  /**
+   * Get hooks for an event, including alias handling
+   */
+  getHooksForEvent(event) {
+    const hooks = this.getHooks().filter((h) => h.enabled !== false);
+    if (event === "stop") {
+      return hooks.filter((h) => h.event === "stop" || h.event === "post-response");
+    }
+    if (event === "post-response") {
+      return hooks.filter((h) => h.event === "stop" || h.event === "post-response");
+    }
+    return hooks.filter((h) => h.event === event);
+  }
+  /**
+   * Execute all hooks for an event
+   *
+   * Sync hooks are executed sequentially and block until complete.
+   * Async hooks are executed in parallel and don't block.
+   */
+  async executeHooks(event, context) {
+    if (!this.isEnabled()) {
+      return [];
+    }
+    const fullContext = {
+      ...context,
+      event,
+      workspace: this.workspaceRoot
+    };
+    const hooks = this.getHooksForEvent(event).filter(
+      (h) => this.matchesFilter(h.filter, fullContext) && this.matchesMatcher(h, fullContext)
+    );
+    if (hooks.length === 0) {
+      return [];
+    }
+    const syncHooks = hooks.filter((h) => !h.async);
+    const asyncHooks = hooks.filter((h) => h.async);
+    const results = [];
+    for (const hook of syncHooks) {
+      const result = await this.executeHook(hook, fullContext);
+      results.push(result);
+      if (result.response?.continue === false) {
+        break;
+      }
+    }
+    if (asyncHooks.length > 0) {
+      const asyncResults = await Promise.all(
+        asyncHooks.map((hook) => this.executeHook(hook, fullContext))
+      );
+      results.push(...asyncResults);
+    }
+    return results;
+  }
+  /**
+   * Test a hook by executing it with a sample context
+   */
+  async testHook(hook) {
+    const context = {
+      event: hook.event,
+      workspace: this.workspaceRoot,
+      tool: "test_tool",
+      toolCallId: "test_123",
+      args: { test: true },
+      success: true,
+      path: "test/file.ts",
+      changeType: "modify",
+      instruction: "Test instruction",
+      tokensUsed: 100
+    };
+    return this.executeHook(hook, context);
+  }
+  /**
+   * Get a summary of hooks by event
+   */
+  getSummary() {
+    const events = [
+      "pre-tool",
+      "post-tool",
+      "file-modified",
+      "pre-prompt",
+      "stop",
+      "post-response",
+      // Alias for 'stop'
+      "session-error",
+      "subagent-stop",
+      "session-start",
+      "session-end",
+      "permission-request",
+      "notification"
+    ];
+    const summary = {};
+    for (const event of events) {
+      const eventHooks = this.getHooks().filter((h) => h.event === event);
+      summary[event] = {
+        total: eventHooks.length,
+        enabled: eventHooks.filter((h) => h.enabled !== false).length
+      };
+    }
+    return summary;
+  }
+};
+
+export {
+  HookManager
+};
+/**
+ * Hook Manager - Executes lifecycle hooks based on config
+ * @license Apache-2.0
+ */

package/dist/chunk-UPR5PKX4.cjs

@@ -0,0 +1,199 @@
+"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 _chunkXTHHDIBGcjs = require('./chunk-XTHHDIBG.cjs');
+
+// src/session/SessionManager.ts
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _crypto = require('crypto'); var _crypto2 = _interopRequireDefault(_crypto);
+var SessionManager = class {
+  constructor(baseDir) {
+    this.currentSession = null;
+    this.index = null;
+    this.sessionsDir = _nullishCoalesce(baseDir, () => ( _chunkXTHHDIBGcjs.AUTOHAND_PATHS.sessions));
+  }
+  async initialize() {
+    await _fsextra2.default.ensureDir(this.sessionsDir);
+    await this.loadIndex();
+  }
+  async createSession(projectPath, model) {
+    const sessionId = this.generateSessionId();
+    const sessionDir = _path2.default.join(this.sessionsDir, sessionId);
+    await _fsextra2.default.ensureDir(sessionDir);
+    const metadata = {
+      sessionId,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
+      projectPath: _path2.default.resolve(projectPath),
+      projectName: _path2.default.basename(projectPath),
+      model,
+      messageCount: 0,
+      status: "active"
+    };
+    const session = new Session(sessionDir, metadata);
+    await session.save();
+    this.currentSession = session;
+    await this.addToIndex(session.metadata);
+    return session;
+  }
+  async loadSession(sessionId) {
+    const sessionDir = _path2.default.join(this.sessionsDir, sessionId);
+    if (!await _fsextra2.default.pathExists(sessionDir)) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const metadataPath = _path2.default.join(sessionDir, "metadata.json");
+    const metadata = await _fsextra2.default.readJson(metadataPath);
+    const session = new Session(sessionDir, metadata);
+    await session.load();
+    this.currentSession = session;
+    return session;
+  }
+  async listSessions(filter) {
+    await this.loadIndex();
+    if (!this.index) return [];
+    let sessions = this.index.sessions;
+    if (_optionalChain([filter, 'optionalAccess', _ => _.project])) {
+      const projectPath = _path2.default.resolve(filter.project);
+      const sessionIds = this.index.byProject[projectPath] || [];
+      sessions = sessions.filter((s) => sessionIds.includes(s.id));
+    }
+    if (_optionalChain([filter, 'optionalAccess', _2 => _2.since])) {
+      sessions = sessions.filter((s) => new Date(s.createdAt) >= filter.since);
+    }
+    const fullMetadata = [];
+    for (const s of sessions) {
+      const sessionDir = _path2.default.join(this.sessionsDir, s.id);
+      const metadataPath = _path2.default.join(sessionDir, "metadata.json");
+      if (await _fsextra2.default.pathExists(metadataPath)) {
+        const metadata = await _fsextra2.default.readJson(metadataPath);
+        fullMetadata.push(metadata);
+      }
+    }
+    return fullMetadata.sort(
+      (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+    );
+  }
+  async getLastSession(projectPath) {
+    const sessions = await this.listSessions(projectPath ? { project: projectPath } : void 0);
+    return sessions[0] || null;
+  }
+  async closeSession(summary) {
+    if (!this.currentSession) return;
+    this.currentSession.metadata.closedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.currentSession.metadata.lastActiveAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.currentSession.metadata.status = "completed";
+    if (summary) {
+      this.currentSession.metadata.summary = summary;
+    }
+    await this.currentSession.save();
+    await this.updateIndex(this.currentSession.metadata);
+    this.currentSession = null;
+  }
+  getCurrentSession() {
+    return this.currentSession;
+  }
+  generateSessionId() {
+    const timestamp = Date.now();
+    const uuid = _crypto2.default.randomUUID();
+    return `${uuid}-${timestamp}`;
+  }
+  async loadIndex() {
+    const indexPath = _path2.default.join(this.sessionsDir, "index.json");
+    if (await _fsextra2.default.pathExists(indexPath)) {
+      this.index = await _fsextra2.default.readJson(indexPath);
+    } else {
+      this.index = { sessions: [], byProject: {} };
+    }
+  }
+  async saveIndex() {
+    const indexPath = _path2.default.join(this.sessionsDir, "index.json");
+    await _fsextra2.default.writeJson(indexPath, this.index, { spaces: 2 });
+  }
+  async addToIndex(metadata) {
+    if (!this.index) await this.loadIndex();
+    if (!this.index) return;
+    this.index.sessions.push({
+      id: metadata.sessionId,
+      projectPath: metadata.projectPath,
+      createdAt: metadata.createdAt,
+      summary: metadata.summary
+    });
+    if (!this.index.byProject[metadata.projectPath]) {
+      this.index.byProject[metadata.projectPath] = [];
+    }
+    this.index.byProject[metadata.projectPath].push(metadata.sessionId);
+    await this.saveIndex();
+  }
+  async updateIndex(metadata) {
+    if (!this.index) return;
+    const session = this.index.sessions.find((s) => s.id === metadata.sessionId);
+    if (session) {
+      session.summary = metadata.summary;
+    }
+    await this.saveIndex();
+  }
+};
+var Session = class {
+  constructor(sessionDir, metadata) {
+    this.messages = [];
+    this.state = null;
+    this.sessionDir = sessionDir;
+    this.metadata = metadata;
+  }
+  async append(message) {
+    this.messages.push(message);
+    this.metadata.messageCount = this.messages.length;
+    this.metadata.lastActiveAt = (/* @__PURE__ */ new Date()).toISOString();
+    const conversationPath = _path2.default.join(this.sessionDir, "conversation.jsonl");
+    await _fsextra2.default.appendFile(conversationPath, JSON.stringify(message) + "\n");
+    await this.save();
+  }
+  async appendTransient(message) {
+    const conversationPath = _path2.default.join(this.sessionDir, "conversation.jsonl");
+    await _fsextra2.default.appendFile(conversationPath, JSON.stringify(message) + "\n");
+  }
+  async updateState(state) {
+    this.state = state;
+    const statePath = _path2.default.join(this.sessionDir, "state.json");
+    await _fsextra2.default.writeJson(statePath, state, { spaces: 2 });
+  }
+  async save() {
+    const metadataPath = _path2.default.join(this.sessionDir, "metadata.json");
+    await _fsextra2.default.writeJson(metadataPath, this.metadata, { spaces: 2 });
+  }
+  async load() {
+    const conversationPath = _path2.default.join(this.sessionDir, "conversation.jsonl");
+    if (await _fsextra2.default.pathExists(conversationPath)) {
+      const content = await _fsextra2.default.readFile(conversationPath, "utf-8");
+      this.messages = content.trim().split("\n").filter((line) => line).map((line) => JSON.parse(line));
+    }
+    const statePath = _path2.default.join(this.sessionDir, "state.json");
+    if (await _fsextra2.default.pathExists(statePath)) {
+      this.state = await _fsextra2.default.readJson(statePath);
+    }
+  }
+  getMessages() {
+    return this.messages;
+  }
+  getState() {
+    return this.state;
+  }
+  async close(summary) {
+    this.metadata.closedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.metadata.status = "completed";
+    if (summary) {
+      this.metadata.summary = summary;
+    }
+    await this.save();
+  }
+};
+
+
+
+
+exports.SessionManager = SessionManager; exports.Session = Session;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */