@within-7/minto 0.4.2 → 0.4.3

package/dist/utils/agentTranscripts.js

@@ -1,641 +0,0 @@
-import {
-  existsSync,
-  readFileSync,
-  writeFileSync,
-  mkdirSync,
-  readdirSync,
-  unlinkSync
-} from "fs";
-import { join } from "path";
-import { homedir } from "os";
-import { EventEmitter } from "events";
-import { debug as debugLogger } from "./debugLogger.js";
-class AgentTranscriptEmitter extends EventEmitter {
-  static instance;
-  // Throttle configuration
-  static THROTTLE_INTERVAL = 100;
-  // ms between message_appended events
-  static HIGH_PRIORITY_EVENTS = [
-    "created",
-    "completed",
-    "failed",
-    "interrupted",
-    "status_changed"
-  ];
-  // Throttle state per agent
-  throttleState = /* @__PURE__ */ new Map();
-  constructor() {
-    super();
-    this.setMaxListeners(100);
-  }
-  static getInstance() {
-    if (!AgentTranscriptEmitter.instance) {
-      AgentTranscriptEmitter.instance = new AgentTranscriptEmitter();
-    }
-    return AgentTranscriptEmitter.instance;
-  }
-  /**
-   * Get or create throttle state for an agent
-   */
-  getThrottleState(agentId) {
-    let state = this.throttleState.get(agentId);
-    if (!state) {
-      state = {
-        lastEmitTime: 0,
-        pendingEvent: null,
-        timeoutId: null
-      };
-      this.throttleState.set(agentId, state);
-    }
-    return state;
-  }
-  /**
-   * Clean up throttle state for an agent (call when agent completes)
-   */
-  cleanupThrottleState(agentId) {
-    const state = this.throttleState.get(agentId);
-    if (state?.timeoutId) {
-      clearTimeout(state.timeoutId);
-    }
-    this.throttleState.delete(agentId);
-  }
-  /**
-   * Internal emit that actually sends the event
-   */
-  doEmit(event) {
-    this.emit("update", event);
-    this.emit(`update:${event.agentId}`, event.transcript);
-    if (event.toolUseId) {
-      this.emit(`update:toolUse:${event.toolUseId}`, event.transcript);
-    }
-    this.emit(event.type, event);
-    debugLogger.trace("TRANSCRIPT_EVENT_EMITTED", {
-      type: event.type,
-      agentId: event.agentId,
-      status: event.transcript.status
-    });
-  }
-  /**
-   * Emit a transcript update event
-   *
-   * High-priority events (status changes, completion) are emitted immediately.
-   * Low-priority events (message_appended) are throttled to reduce UI flickering.
-   */
-  emitUpdate(event) {
-    if (AgentTranscriptEmitter.HIGH_PRIORITY_EVENTS.includes(event.type)) {
-      if (event.type === "completed" || event.type === "failed" || event.type === "interrupted") {
-        const state2 = this.throttleState.get(event.agentId);
-        if (state2?.pendingEvent) {
-          this.doEmit(state2.pendingEvent);
-        }
-        this.cleanupThrottleState(event.agentId);
-      }
-      this.doEmit(event);
-      return;
-    }
-    const state = this.getThrottleState(event.agentId);
-    const now = Date.now();
-    const timeSinceLastEmit = now - state.lastEmitTime;
-    if (timeSinceLastEmit >= AgentTranscriptEmitter.THROTTLE_INTERVAL) {
-      state.lastEmitTime = now;
-      state.pendingEvent = null;
-      if (state.timeoutId) {
-        clearTimeout(state.timeoutId);
-        state.timeoutId = null;
-      }
-      this.doEmit(event);
-    } else {
-      state.pendingEvent = event;
-      if (!state.timeoutId) {
-        const delay = AgentTranscriptEmitter.THROTTLE_INTERVAL - timeSinceLastEmit;
-        state.timeoutId = setTimeout(() => {
-          const currentState = this.throttleState.get(event.agentId);
-          if (currentState?.pendingEvent) {
-            currentState.lastEmitTime = Date.now();
-            const pendingEvent = currentState.pendingEvent;
-            currentState.pendingEvent = null;
-            currentState.timeoutId = null;
-            this.doEmit(pendingEvent);
-          }
-        }, delay);
-      }
-    }
-  }
-  /**
-   * Subscribe to updates for a specific agent
-   */
-  onAgentUpdate(agentId, callback) {
-    const eventName = `update:${agentId}`;
-    this.on(eventName, callback);
-    return () => this.off(eventName, callback);
-  }
-  /**
-   * Subscribe to updates for a specific toolUseId
-   */
-  onToolUseUpdate(toolUseId, callback) {
-    const eventName = `update:toolUse:${toolUseId}`;
-    this.on(eventName, callback);
-    return () => this.off(eventName, callback);
-  }
-  /**
-   * Subscribe to all updates (any agent)
-   */
-  onAnyUpdate(callback) {
-    this.on("update", callback);
-    return () => this.off("update", callback);
-  }
-  /**
-   * Subscribe to status change events
-   */
-  onStatusChange(callback) {
-    this.on("status_changed", callback);
-    return () => this.off("status_changed", callback);
-  }
-}
-const transcriptEmitter = AgentTranscriptEmitter.getInstance();
-const activeTranscripts = /* @__PURE__ */ new Map();
-function getTranscriptsDirectory() {
-  const configDir = process.env.MINTO_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".minto");
-  return join(configDir, "transcripts");
-}
-function ensureTranscriptsDirectory() {
-  const dir = getTranscriptsDirectory();
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-}
-function getTranscriptPath(agentId) {
-  return join(getTranscriptsDirectory(), `${agentId}.json`);
-}
-function createAgentTranscript(options) {
-  const transcript = {
-    ...options,
-    startTime: Date.now(),
-    status: "running",
-    messages: options.messages || [],
-    toolUseCount: options.toolUseCount || 0,
-    tokenUsage: {
-      inputTokens: options.tokenUsage?.inputTokens || 0,
-      outputTokens: options.tokenUsage?.outputTokens || 0,
-      cacheReadTokens: options.tokenUsage?.cacheReadTokens,
-      cacheCreationTokens: options.tokenUsage?.cacheCreationTokens
-    }
-  };
-  activeTranscripts.set(options.agentId, transcript);
-  saveAgentTranscript(transcript, false);
-  debugLogger.info("AGENT_TRANSCRIPT_CREATED", {
-    agentId: options.agentId,
-    agentType: options.agentType,
-    description: options.description
-  });
-  transcriptEmitter.emitUpdate({
-    type: "created",
-    agentId: options.agentId,
-    toolUseId: options.toolUseId,
-    transcript
-  });
-  return transcript;
-}
-function saveAgentTranscript(transcript, emitEvent = true) {
-  ensureTranscriptsDirectory();
-  const filePath = getTranscriptPath(transcript.agentId);
-  try {
-    writeFileSync(filePath, JSON.stringify(transcript, null, 2), "utf-8");
-    activeTranscripts.set(transcript.agentId, transcript);
-    debugLogger.trace("AGENT_TRANSCRIPT_SAVED", {
-      agentId: transcript.agentId,
-      status: transcript.status,
-      messageCount: transcript.messages.length
-    });
-    if (emitEvent) {
-      transcriptEmitter.emitUpdate({
-        type: "updated",
-        agentId: transcript.agentId,
-        toolUseId: transcript.toolUseId,
-        transcript
-      });
-    }
-  } catch (error) {
-    debugLogger.error("AGENT_TRANSCRIPT_SAVE_FAILED", {
-      agentId: transcript.agentId,
-      error: error instanceof Error ? error.message : String(error)
-    });
-    throw error;
-  }
-}
-function getAgentTranscript(agentId) {
-  const cached = activeTranscripts.get(agentId);
-  if (cached) {
-    return cached;
-  }
-  const filePath = getTranscriptPath(agentId);
-  if (!existsSync(filePath)) {
-    return null;
-  }
-  try {
-    const content = readFileSync(filePath, "utf-8");
-    const transcript = JSON.parse(content);
-    activeTranscripts.set(agentId, transcript);
-    return transcript;
-  } catch (error) {
-    debugLogger.error("AGENT_TRANSCRIPT_READ_FAILED", {
-      agentId,
-      error: error instanceof Error ? error.message : String(error)
-    });
-    return null;
-  }
-}
-function updateAgentTranscript(agentId, updates, emitEvent = true) {
-  const transcript = getAgentTranscript(agentId);
-  if (!transcript) {
-    debugLogger.warn("AGENT_TRANSCRIPT_UPDATE_NOT_FOUND", { agentId });
-    return null;
-  }
-  const updated = {
-    ...transcript,
-    ...updates,
-    // Merge token usage if provided
-    tokenUsage: updates.tokenUsage ? { ...transcript.tokenUsage, ...updates.tokenUsage } : transcript.tokenUsage
-  };
-  saveAgentTranscript(updated, emitEvent);
-  return updated;
-}
-function appendMessageToTranscript(agentId, message) {
-  const transcript = getAgentTranscript(agentId);
-  if (!transcript) {
-    debugLogger.warn("AGENT_TRANSCRIPT_APPEND_NOT_FOUND", { agentId });
-    return null;
-  }
-  const updatedMessages = [...transcript.messages, message];
-  let newToolUseCount = transcript.toolUseCount;
-  if (message.type === "assistant") {
-    const content = message.message.content;
-    if (Array.isArray(content)) {
-      const toolUses = content.filter((block) => block.type === "tool_use");
-      newToolUseCount += toolUses.length;
-    }
-  }
-  const updated = {
-    ...transcript,
-    messages: updatedMessages,
-    toolUseCount: newToolUseCount
-  };
-  activeTranscripts.set(agentId, updated);
-  saveAgentTranscript(updated, false);
-  transcriptEmitter.emitUpdate({
-    type: "message_appended",
-    agentId,
-    toolUseId: transcript.toolUseId,
-    transcript: updated
-  });
-  return updated;
-}
-function completeAgentTranscript(agentId, tokenUsage) {
-  const transcript = getAgentTranscript(agentId);
-  if (!transcript) {
-    return null;
-  }
-  const previousStatus = transcript.status;
-  const mergedTokenUsage = tokenUsage ? { ...transcript.tokenUsage, ...tokenUsage } : transcript.tokenUsage;
-  const updated = updateAgentTranscript(
-    agentId,
-    {
-      status: "completed",
-      endTime: Date.now(),
-      tokenUsage: mergedTokenUsage
-    },
-    false
-  );
-  if (updated) {
-    transcriptEmitter.emitUpdate({
-      type: "completed",
-      agentId,
-      toolUseId: updated.toolUseId,
-      transcript: updated,
-      previousStatus
-    });
-    transcriptEmitter.emitUpdate({
-      type: "status_changed",
-      agentId,
-      toolUseId: updated.toolUseId,
-      transcript: updated,
-      previousStatus
-    });
-  }
-  return updated;
-}
-function failAgentTranscript(agentId, error) {
-  const transcript = getAgentTranscript(agentId);
-  if (!transcript) {
-    return null;
-  }
-  const previousStatus = transcript.status;
-  const updated = updateAgentTranscript(
-    agentId,
-    {
-      status: "failed",
-      endTime: Date.now(),
-      metadata: error ? { error } : void 0
-    },
-    false
-  );
-  if (updated) {
-    transcriptEmitter.emitUpdate({
-      type: "failed",
-      agentId,
-      toolUseId: updated.toolUseId,
-      transcript: updated,
-      previousStatus
-    });
-    transcriptEmitter.emitUpdate({
-      type: "status_changed",
-      agentId,
-      toolUseId: updated.toolUseId,
-      transcript: updated,
-      previousStatus
-    });
-  }
-  return updated;
-}
-function interruptAgentTranscript(agentId) {
-  const transcript = getAgentTranscript(agentId);
-  if (!transcript) {
-    return null;
-  }
-  const previousStatus = transcript.status;
-  const updated = updateAgentTranscript(
-    agentId,
-    {
-      status: "interrupted",
-      endTime: Date.now()
-    },
-    false
-  );
-  if (updated) {
-    transcriptEmitter.emitUpdate({
-      type: "interrupted",
-      agentId,
-      toolUseId: updated.toolUseId,
-      transcript: updated,
-      previousStatus
-    });
-    transcriptEmitter.emitUpdate({
-      type: "status_changed",
-      agentId,
-      toolUseId: updated.toolUseId,
-      transcript: updated,
-      previousStatus
-    });
-  }
-  return updated;
-}
-function addRetryEventToTranscript(agentId, event) {
-  const transcript = getAgentTranscript(agentId);
-  if (!transcript) {
-    return null;
-  }
-  const retryEvents = transcript.retryEvents || [];
-  retryEvents.push({
-    ...event,
-    timestamp: Date.now()
-  });
-  return updateAgentTranscript(agentId, {
-    retryEvents
-  });
-}
-function listAgentTranscripts(options = {}) {
-  ensureTranscriptsDirectory();
-  const dir = getTranscriptsDirectory();
-  const files = readdirSync(dir).filter((f) => f.endsWith(".json"));
-  const summaries = [];
-  for (const file of files) {
-    try {
-      const content = readFileSync(join(dir, file), "utf-8");
-      const transcript = JSON.parse(content);
-      if (options.status) {
-        const statuses = Array.isArray(options.status) ? options.status : [options.status];
-        if (!statuses.includes(transcript.status)) {
-          continue;
-        }
-      }
-      if (options.agentType && transcript.agentType !== options.agentType) {
-        continue;
-      }
-      if (options.since && transcript.startTime < options.since) {
-        continue;
-      }
-      summaries.push({
-        agentId: transcript.agentId,
-        agentType: transcript.agentType,
-        description: transcript.description,
-        status: transcript.status,
-        startTime: transcript.startTime,
-        endTime: transcript.endTime,
-        messageCount: transcript.messages.length,
-        toolUseCount: transcript.toolUseCount,
-        model: transcript.model
-      });
-    } catch {
-      continue;
-    }
-  }
-  summaries.sort((a, b) => {
-    const order = options.sortOrder === "asc" ? 1 : -1;
-    return order * (b.startTime - a.startTime);
-  });
-  if (options.limit && options.limit > 0) {
-    return summaries.slice(0, options.limit);
-  }
-  return summaries;
-}
-function deleteAgentTranscript(agentId) {
-  const filePath = getTranscriptPath(agentId);
-  activeTranscripts.delete(agentId);
-  if (!existsSync(filePath)) {
-    return false;
-  }
-  try {
-    unlinkSync(filePath);
-    debugLogger.info("AGENT_TRANSCRIPT_DELETED", { agentId });
-    return true;
-  } catch (error) {
-    debugLogger.error("AGENT_TRANSCRIPT_DELETE_FAILED", {
-      agentId,
-      error: error instanceof Error ? error.message : String(error)
-    });
-    return false;
-  }
-}
-function cleanupOldTranscripts(maxAge = 7 * 24 * 60 * 60 * 1e3) {
-  const cutoff = Date.now() - maxAge;
-  const transcripts = listAgentTranscripts();
-  let deleted = 0;
-  for (const summary of transcripts) {
-    if ((summary.status === "completed" || summary.status === "failed") && summary.startTime < cutoff) {
-      if (deleteAgentTranscript(summary.agentId)) {
-        deleted++;
-      }
-    }
-  }
-  debugLogger.info("AGENT_TRANSCRIPTS_CLEANUP", { deleted, maxAge });
-  return deleted;
-}
-function getResumableTranscript(agentId) {
-  const transcript = getAgentTranscript(agentId);
-  if (!transcript) {
-    return null;
-  }
-  if (transcript.status !== "running" && transcript.status !== "interrupted") {
-    debugLogger.warn("AGENT_TRANSCRIPT_NOT_RESUMABLE", {
-      agentId,
-      status: transcript.status
-    });
-    return null;
-  }
-  return transcript;
-}
-function canResumeTranscript(agentId) {
-  return getResumableTranscript(agentId) !== null;
-}
-function getRunningTranscripts() {
-  return listAgentTranscripts({ status: "running" });
-}
-function clearTranscriptCache() {
-  activeTranscripts.clear();
-}
-const toolUseToAgentMap = /* @__PURE__ */ new Map();
-const agentToToolUseMap = /* @__PURE__ */ new Map();
-function registerToolUseAgent(toolUseId, agentId) {
-  toolUseToAgentMap.set(toolUseId, agentId);
-  agentToToolUseMap.set(agentId, toolUseId);
-}
-function getAgentIdByToolUseId(toolUseId) {
-  return toolUseToAgentMap.get(toolUseId) || null;
-}
-function getToolUseIdByAgentId(agentId) {
-  const cached = agentToToolUseMap.get(agentId);
-  if (cached) {
-    return cached;
-  }
-  if (!diskMappingsRestored) {
-    restoreToolUseAgentMappings();
-    const afterRestore = agentToToolUseMap.get(agentId);
-    if (afterRestore) {
-      return afterRestore;
-    }
-  }
-  const transcript = getAgentTranscript(agentId);
-  if (transcript?.toolUseId) {
-    registerToolUseAgent(transcript.toolUseId, agentId);
-    return transcript.toolUseId;
-  }
-  return null;
-}
-let diskMappingsRestored = false;
-function findTranscriptByToolUseIdOnDisk(toolUseId) {
-  const dir = getTranscriptsDirectory();
-  if (!existsSync(dir)) return null;
-  try {
-    const files = readdirSync(dir).filter((f) => f.endsWith(".json"));
-    for (const file of files) {
-      try {
-        const content = readFileSync(join(dir, file), "utf-8");
-        const transcript = JSON.parse(content);
-        if (transcript.toolUseId === toolUseId) {
-          activeTranscripts.set(transcript.agentId, transcript);
-          registerToolUseAgent(toolUseId, transcript.agentId);
-          debugLogger.trace("TRANSCRIPT_FOUND_ON_DISK", {
-            toolUseId,
-            agentId: transcript.agentId
-          });
-          return transcript;
-        }
-      } catch {
-        continue;
-      }
-    }
-  } catch (error) {
-    debugLogger.error("TRANSCRIPT_DISK_SCAN_FAILED", {
-      error: error instanceof Error ? error.message : String(error)
-    });
-  }
-  return null;
-}
-function restoreToolUseAgentMappings() {
-  if (diskMappingsRestored) return;
-  const dir = getTranscriptsDirectory();
-  if (!existsSync(dir)) {
-    diskMappingsRestored = true;
-    return;
-  }
-  try {
-    const files = readdirSync(dir).filter((f) => f.endsWith(".json"));
-    let restoredCount = 0;
-    for (const file of files) {
-      try {
-        const content = readFileSync(join(dir, file), "utf-8");
-        const transcript = JSON.parse(content);
-        if (transcript.toolUseId && transcript.agentId) {
-          registerToolUseAgent(transcript.toolUseId, transcript.agentId);
-          activeTranscripts.set(transcript.agentId, transcript);
-          restoredCount++;
-        }
-      } catch {
-        continue;
-      }
-    }
-    debugLogger.info("TRANSCRIPT_MAPPINGS_RESTORED", {
-      count: restoredCount,
-      totalFiles: files.length
-    });
-  } catch (error) {
-    debugLogger.error("TRANSCRIPT_RESTORE_FAILED", {
-      error: error instanceof Error ? error.message : String(error)
-    });
-  }
-  diskMappingsRestored = true;
-}
-function getAgentTranscriptByToolUseId(toolUseId) {
-  const agentId = getAgentIdByToolUseId(toolUseId);
-  if (agentId) {
-    return getAgentTranscript(agentId);
-  }
-  if (!diskMappingsRestored) {
-    restoreToolUseAgentMappings();
-    const agentIdAfterRestore = getAgentIdByToolUseId(toolUseId);
-    if (agentIdAfterRestore) {
-      return getAgentTranscript(agentIdAfterRestore);
-    }
-  }
-  return findTranscriptByToolUseIdOnDisk(toolUseId);
-}
-function clearToolUseAgentMap() {
-  toolUseToAgentMap.clear();
-  agentToToolUseMap.clear();
-}
-export {
-  addRetryEventToTranscript,
-  appendMessageToTranscript,
-  canResumeTranscript,
-  cleanupOldTranscripts,
-  clearToolUseAgentMap,
-  clearTranscriptCache,
-  completeAgentTranscript,
-  createAgentTranscript,
-  deleteAgentTranscript,
-  failAgentTranscript,
-  getAgentIdByToolUseId,
-  getAgentTranscript,
-  getAgentTranscriptByToolUseId,
-  getResumableTranscript,
-  getRunningTranscripts,
-  getToolUseIdByAgentId,
-  interruptAgentTranscript,
-  listAgentTranscripts,
-  registerToolUseAgent,
-  restoreToolUseAgentMappings,
-  saveAgentTranscript,
-  transcriptEmitter,
-  updateAgentTranscript
-};
-//# sourceMappingURL=agentTranscripts.js.map