@within-7/minto 0.1.7 → 0.2.0

package/dist/utils/agentTranscripts.js

@@ -0,0 +1,641 @@
+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