loadtoagent 1.0.0

package/src/agentMonitor/genericParser.js

@@ -0,0 +1,244 @@
+'use strict';
+
+const path = require('path');
+
+const TOOL_START_PATTERN = /tool_use|tool-call|tool_start/;
+const TOOL_END_PATTERN = /tool_result|tool-result|tool_end/;
+
+function createGenericParser(dependencies) {
+  const {
+    ACTIVE_THRESHOLD_MS,
+    STALE_TURN_THRESHOLD_MS,
+    addLifecycle,
+    addMessage,
+    baseSession,
+    compactText,
+    contextInfo,
+    finalizeUsage,
+    modelContextWindow,
+    readJson,
+    readJsonLines,
+    settleLifecycle,
+    sumUsage,
+    timestamp,
+    trimSession,
+  } = dependencies;
+
+  function normalizeUsage(raw = {}) {
+    const usage = raw.usageMetadata || raw.usage_metadata || raw.usage
+      || raw.stats || raw.tokens || raw;
+    return finalizeUsage({
+      input: usage.input_tokens || usage.inputTokenCount || usage.prompt_tokens || usage.promptTokenCount,
+      cachedInput: usage.cached_input_tokens || usage.cachedContentTokenCount || usage.cached_tokens,
+      cacheWrite: usage.cache_creation_input_tokens,
+      output: usage.output_tokens || usage.candidatesTokenCount
+        || usage.completion_tokens || usage.response_tokens,
+      reasoning: usage.reasoning_tokens || usage.thoughtsTokenCount,
+      total: usage.total_tokens || usage.totalTokenCount || usage.total_token_count,
+    });
+  }
+
+  function flattenRows(value, out = [], depth = 0, seen = new Set()) {
+    if (depth > 6 || value == null) return out;
+    if (Array.isArray(value)) {
+      for (const item of value) flattenRows(item, out, depth + 1, seen);
+      return out;
+    }
+    if (typeof value !== 'object' || seen.has(value)) return out;
+    seen.add(value);
+    const role = value.role || value.author || value.sender;
+    const deltaText = typeof value.delta === 'string' ? value.delta : '';
+    const text = compactText(value.text || value.content || value.message
+      || value.response || value.prompt || deltaText);
+    if (role && text) out.push({ value, order: out.length });
+    for (const key of ['messages', 'history', 'turns', 'events', 'conversation']) {
+      if (value[key]) flattenRows(value[key], out, depth + 1, seen);
+    }
+    return out;
+  }
+
+  function readSessionFile(fileInfo) {
+    const isJsonl = /\.jsonl$/i.test(fileInfo.file);
+    return isJsonl
+      ? readJsonLines(fileInfo.file)
+      : { rows: [readJson(fileInfo.file, {})], truncated: false };
+  }
+
+  function initializeSession(fileInfo, provider, parsed) {
+    const rows = parsed.rows.filter(Boolean);
+    const root = rows.length === 1 ? rows[0] : { events: rows };
+    const externalId = root.session_id || root.sessionId || root.id
+      || path.basename(fileInfo.file).replace(/\.(jsonl?|ndjson)$/i, '');
+    const session = baseSession(provider, externalId, fileInfo.file, fileInfo);
+    session.truncated = parsed.truncated;
+    session.cwd = root.cwd || root.projectPath || root.project_path || '';
+    session.model = root.model || root.modelId || '';
+    session.startedAt = timestamp(root.startTime || root.startedAt || root.created_at, session.updatedAt);
+    session.parentId = root.parent_session_id ? `${provider}:${root.parent_session_id}` : null;
+    session.depth = session.parentId ? 1 : 0;
+    return { rows, root, session };
+  }
+
+  function recordToolStart(session, event) {
+    const tool = event.tool_name || event.name || event.tool || 'tool';
+    addMessage(session, {
+      id: event.id,
+      role: 'tool',
+      type: 'tool',
+      title: tool,
+      text: compactText(event.parameters || event.args || event.input, 1000),
+      status: 'started',
+      timestamp: event.timestamp,
+    });
+    addLifecycle(session, {
+      id: event.id,
+      type: 'tool',
+      label: tool,
+      status: 'running',
+      timestamp: event.timestamp,
+    });
+  }
+
+  function recordToolEnd(session, event) {
+    const callId = event.tool_call_id || event.tool_use_id || event.id;
+    settleLifecycle(session, callId, event.error ? 'failed' : 'done', event.timestamp);
+    addLifecycle(session, {
+      id: `result:${event.id || event.tool_call_id}`,
+      type: 'tool-result',
+      label: '도구 완료',
+      status: event.error ? 'failed' : 'done',
+      timestamp: event.timestamp,
+    });
+  }
+
+  function processEvents(session, events) {
+    const state = { running: false, failed: false };
+    for (const event of events) {
+      const type = String(event.type || event.event || event.kind || '').toLowerCase();
+      if (type === 'init') {
+        session.model = event.model || session.model;
+        session.externalId = event.session_id || event.sessionId || session.externalId;
+        addLifecycle(session, {
+          id: `init:${event.timestamp || 0}`,
+          type: 'session-start',
+          label: '세션 시작',
+          status: 'done',
+          timestamp: event.timestamp,
+        });
+      }
+      if (TOOL_START_PATTERN.test(type)) {
+        recordToolStart(session, event);
+        state.running = true;
+      }
+      if (TOOL_END_PATTERN.test(type)) recordToolEnd(session, event);
+      if (type === 'result' || /session_end|completed/.test(type)) state.running = false;
+      if (type === 'error' || event.error) state.failed = true;
+      const usage = normalizeUsage(event);
+      if (usage.total) session.usage = usage;
+    }
+    return state;
+  }
+
+  function normalizedMessage(row, session) {
+    const item = row.value;
+    const eventType = String(item.type || item.event || item.kind || '').toLowerCase();
+    if (TOOL_START_PATTERN.test(eventType) || TOOL_END_PATTERN.test(eventType)) return null;
+    const rawRole = String(item.role || item.author || item.sender || '').toLowerCase();
+    const role = /assistant|model|agent/.test(rawRole)
+      ? 'assistant'
+      : (rawRole === 'user' ? 'user' : 'system');
+    const deltaText = typeof item.delta === 'string' ? item.delta : '';
+    const text = compactText(item.text || item.content || item.message
+      || item.response || item.prompt || deltaText);
+    const id = item.id || item.uuid || '';
+    const recordedAt = timestamp(item.timestamp || item.created_at, session.updatedAt);
+    const isDelta = item.is_delta === true || item.delta === true
+      || typeof item.delta === 'string'
+      || /(?:^|[_-])delta(?:$|[_-])/.test(eventType);
+    return {
+      item,
+      role,
+      text,
+      id,
+      recordedAt,
+      isDelta,
+      key: id ? `${role}:${id}` : `${role}:${text}:${recordedAt}`,
+      order: row.order,
+    };
+  }
+
+  function processMessages(session, root) {
+    const messages = new Map();
+    const usages = [];
+    let firstUser = '';
+    for (const row of flattenRows(root)) {
+      const message = normalizedMessage(row, session);
+      if (!message) continue;
+      const previous = messages.get(message.key);
+      const mergedText = previous && message.isDelta
+        ? `${previous.text}${message.text}`
+        : message.text;
+      if (!previous || message.isDelta || message.text.length >= previous.text.length) {
+        messages.set(message.key, {
+          id: message.id,
+          role: message.role,
+          text: mergedText,
+          timestamp: message.recordedAt,
+          order: previous ? previous.order : message.order,
+        });
+      }
+      if (message.role === 'user' && !firstUser) firstUser = message.text;
+      const usage = normalizeUsage(message.item);
+      if (usage.total) {
+        session.turnUsage = usage;
+        usages.push(usage);
+      }
+    }
+    [...messages.values()]
+      .sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp) || a.order - b.order)
+      .forEach(message => addMessage(session, message));
+    return { firstUser, usages };
+  }
+
+  function finalizeSession(session, provider, root, eventState, messageState, fileInfo) {
+    if (!session.usage.total && messageState.usages.length) {
+      session.usage = sumUsage(messageState.usages);
+    }
+    session.title = messageState.firstUser || `${provider === 'gemini' ? 'Gemini' : 'Grok'} 세션`;
+    const context = modelContextWindow(provider, session.model, root.context_window || root.contextWindow);
+    session.context = contextInfo(session.turnUsage.total || session.usage.total, context);
+    const age = Date.now() - fileInfo.mtimeMs;
+    session.status = eventState.failed
+      ? 'failed'
+      : ((eventState.running && age < STALE_TURN_THRESHOLD_MS) || age < ACTIVE_THRESHOLD_MS
+        ? 'running'
+        : 'idle');
+    session.statusDetail = eventState.failed
+      ? '오류 발생'
+      : (session.status === 'running' ? '실시간 이벤트 수신 중' : '다음 요청 대기');
+    session.statusObserved = eventState.running;
+    trimSession(session);
+    return session;
+  }
+
+  return function parseGeneric(fileInfo, provider) {
+    const parsed = readSessionFile(fileInfo);
+    const initialized = initializeSession(fileInfo, provider, parsed);
+    if (!initialized.rows.length) return null;
+    const events = initialized.rows.length === 1 && Array.isArray(initialized.root.events)
+      ? initialized.root.events
+      : initialized.rows;
+    const eventState = processEvents(initialized.session, events);
+    const messageState = processMessages(initialized.session, initialized.root);
+    return finalizeSession(
+      initialized.session,
+      provider,
+      initialized.root,
+      eventState,
+      messageState,
+      fileInfo,
+    );
+  };
+}
+
+module.exports = { createGenericParser };

package/src/agentMonitor/hierarchy.js

@@ -0,0 +1,248 @@
+'use strict';
+
+function createHierarchyAttacher(dependencies) {
+  const {
+    addMessage,
+    baseSession,
+    collaborationTaskName,
+    compactText,
+    timestamp,
+    trimSession,
+  } = dependencies;
+
+  function indexExistingRelationships(sessions) {
+    const byId = new Map(sessions.map(session => [session.id, session]));
+    for (const session of sessions) session.childIds = [];
+    for (const session of sessions) {
+      if (!session.parentId) continue;
+      const parent = byId.get(session.parentId);
+      if (parent && !parent.childIds.includes(session.id)) parent.childIds.push(session.id);
+    }
+    return byId;
+  }
+
+  function findRecordedChild(sessions, byId, parent, record) {
+    if (record.childId && byId.has(record.childId)) return byId.get(record.childId);
+    return sessions.find(candidate => candidate.parentId === parent.id
+      && ((record.agentPath && candidate.agentPath === record.agentPath)
+        || (record.taskName && candidate.taskName === record.taskName)));
+  }
+
+  function createHistoryChild(parent, record) {
+    const externalId = String(record.childId || `${parent.externalId}:spawn:${record.callId}`).replace(/^codex:/, '');
+    const child = baseSession('codex', externalId, '', {
+      mtimeMs: Date.parse(record.completedAt || record.startedAt || parent.updatedAt) || Date.now(),
+    });
+    child.id = record.childId || child.id;
+    child.parentId = parent.id;
+    child.depth = Number(parent.depth || 0) + 1;
+    child.agentPath = record.agentPath;
+    child.taskName = record.taskName;
+    child.agentName = record.agentName || record.taskName || 'subagent';
+    child.title = record.assignmentObserved
+      ? compactText(record.assignment, 180)
+      : (record.taskName || '서브에이전트 작업');
+    child.sharedGoal = record.sharedGoal || parent.title;
+    child.status = record.status === 'completed' ? 'completed' : (record.status === 'running' ? 'running' : 'idle');
+    child.statusDetail = child.status === 'completed'
+      ? '작업 완료 기록'
+      : (child.status === 'running' ? '실행 시작 관측' : '상태 기록만 확인됨');
+    child.startedAt = timestamp(record.startedAt, parent.startedAt);
+    child.updatedAt = timestamp(record.completedAt || record.startedAt, parent.updatedAt);
+    child.completedAt = timestamp(record.completedAt, null);
+    child.completionObserved = child.status === 'completed';
+    child.result = record.result || '';
+    child.source = 'collaboration-history';
+    child.sourceLabel = 'Codex 협업 이벤트';
+    child.clientKind = parent.clientKind;
+    child.model = parent.model;
+    child.cwd = parent.cwd;
+    child.workspace = parent.workspace;
+    child.projectless = parent.projectless;
+    child.environment = parent.environment;
+    if (child.result) {
+      addMessage(child, {
+        id: `${child.id}:result`,
+        role: 'assistant',
+        text: child.result,
+        timestamp: child.completedAt || child.updatedAt,
+      });
+    }
+    trimSession(child);
+    return child;
+  }
+
+  function resolveChild(sessions, byId, parent, record) {
+    const existing = findRecordedChild(sessions, byId, parent, record);
+    if (existing) return existing;
+    const child = createHistoryChild(parent, record);
+    sessions.push(child);
+    byId.set(child.id, child);
+    return child;
+  }
+
+  function connectCommunications(collaboration, record, child) {
+    for (const communication of collaboration.communications || []) {
+      if (communication.childId) continue;
+      if ((record.agentPath && (communication.from === record.agentPath || communication.to === record.agentPath))
+        || (record.taskName && communication.taskName === record.taskName)) {
+        communication.childId = child.id;
+      }
+    }
+  }
+
+  function synchronizeSpawn(parent, collaboration, retainedByTask, record, child) {
+    record.childId = child.id;
+    record.agentPath = record.agentPath || child.agentPath;
+    record.taskName = record.taskName || child.taskName || collaborationTaskName(child.agentPath);
+    record.agentName = child.agentName || record.agentName;
+    record.result = record.result || child.result || '';
+    if (child.status === 'running' || child.status === 'starting') record.status = 'running';
+    else if (child.status === 'completed' || child.completionObserved || record.result) record.status = 'completed';
+    if (!record.completedAt && child.completedAt) record.completedAt = child.completedAt;
+
+    const retained = retainedByTask.get(record.taskName);
+    record.currentlyRetained = Boolean(retained);
+    if (retained && retained.name && (!child.agentName || child.agentName === child.taskName)) {
+      child.agentName = retained.name;
+    }
+    child.taskName = child.taskName || record.taskName;
+    child.sharedGoal = child.sharedGoal || record.sharedGoal || parent.title;
+    child.delegation = {
+      taskName: record.taskName,
+      assignment: record.assignment,
+      assignmentObserved: record.assignmentObserved,
+      assignmentProtected: record.assignmentProtected,
+      assignmentSource: record.assignmentSource,
+      sharedGoal: record.sharedGoal || child.sharedGoal || parent.title,
+      result: record.result,
+      startedAt: record.startedAt,
+      completedAt: record.completedAt,
+      currentlyRetained: record.currentlyRetained,
+    };
+    if (!parent.childIds.includes(child.id)) parent.childIds.push(child.id);
+    connectCommunications(collaboration, record, child);
+  }
+
+  function inferredSpawn(parent, child) {
+    return {
+      callId: `inferred:${child.id}`,
+      taskName: child.taskName || collaborationTaskName(child.agentPath) || child.agentName,
+      agentPath: child.agentPath,
+      childId: child.id,
+      assignment: '',
+      assignmentObserved: false,
+      assignmentProtected: false,
+      assignmentSource: 'unavailable',
+      sharedGoal: child.sharedGoal || parent.title,
+      status: child.status === 'completed' ? 'completed' : (child.status === 'running' ? 'running' : 'idle'),
+      startedAt: child.startedAt,
+      completedAt: child.completedAt,
+      result: child.result || '',
+      agentName: child.agentName,
+      currentlyRetained: false,
+      inferred: true,
+    };
+  }
+
+  function attachInferredDelegation(parent, child, record) {
+    child.delegation = {
+      taskName: record.taskName,
+      assignment: '',
+      assignmentObserved: false,
+      assignmentProtected: true,
+      assignmentSource: 'unavailable',
+      sharedGoal: child.sharedGoal || parent.title,
+      result: child.result || '',
+      startedAt: child.startedAt,
+      completedAt: child.completedAt,
+      currentlyRetained: false,
+    };
+  }
+
+  function appendInferredCommunications(parent, collaboration, child, record) {
+    const communications = collaboration.communications || (collaboration.communications = []);
+    if (communications.some(event => event.childId === child.id)) return;
+    communications.push({
+      id: `inferred-assignment:${child.id}`,
+      kind: 'assignment',
+      label: '작업 배정 확인',
+      from: parent.agentPath || '/root',
+      to: child.agentPath || child.id,
+      taskName: record.taskName,
+      childId: child.id,
+      text: '',
+      protected: true,
+      timestamp: child.startedAt || parent.updatedAt,
+    });
+    communications.push({
+      id: `inferred-started:${child.id}`,
+      kind: 'started',
+      label: '서브에이전트 실행 시작',
+      from: 'Codex 런타임',
+      to: child.agentPath || child.id,
+      taskName: record.taskName,
+      childId: child.id,
+      text: '',
+      protected: false,
+      timestamp: child.startedAt || parent.updatedAt,
+    });
+    if (!child.result && child.status !== 'completed') return;
+    communications.push({
+      id: `inferred-result:${child.id}`,
+      kind: 'result',
+      label: '결과 반환 확인',
+      from: child.agentPath || child.id,
+      to: parent.agentPath || '/root',
+      taskName: record.taskName,
+      childId: child.id,
+      text: child.result || '작업을 완료하고 메인 AI에 결과를 반환했습니다.',
+      protected: false,
+      timestamp: child.completedAt || child.updatedAt,
+    });
+  }
+
+  function inferUnrecordedChildren(parent, collaboration, byId) {
+    for (const childId of parent.childIds) {
+      const child = byId.get(childId);
+      if (!child || collaboration.spawns.some(record => record.childId === child.id)) continue;
+      const record = inferredSpawn(parent, child);
+      collaboration.spawns.push(record);
+      attachInferredDelegation(parent, child, record);
+      appendInferredCommunications(parent, collaboration, child, record);
+    }
+  }
+
+  function updateMetrics(collaboration) {
+    const spawns = collaboration.spawns;
+    collaboration.metrics = {
+      cumulativeCreated: spawns.length,
+      simultaneousCapacity: Number(collaboration.capacity && collaboration.capacity.subagents || 0),
+      currentlyRunning: spawns.filter(record => record.status === 'running').length,
+      completedRecords: spawns.filter(record => record.status === 'completed').length,
+      retainedCount: collaboration.retainedObserved ? (collaboration.retainedAgents || []).length : null,
+      capacitySource: collaboration.capacity && collaboration.capacity.source || 'unknown',
+      cumulativeSource: spawns.some(record => !record.inferred) ? 'spawn-events' : 'child-sessions',
+    };
+  }
+
+  return function attachHierarchy(sessions) {
+    const byId = indexExistingRelationships(sessions);
+    const parents = sessions.filter(session => session.collaboration
+      && ((Array.isArray(session.collaboration.spawns) && session.collaboration.spawns.length)
+        || (Array.isArray(session.childIds) && session.childIds.length)));
+
+    for (const parent of parents) {
+      const collaboration = parent.collaboration;
+      const retainedByTask = new Map((collaboration.retainedAgents || []).map(agent => [agent.taskName, agent]));
+      for (const record of collaboration.spawns) {
+        const child = resolveChild(sessions, byId, parent, record);
+        synchronizeSpawn(parent, collaboration, retainedByTask, record, child);
+      }
+      inferUnrecordedChildren(parent, collaboration, byId);
+      updateMetrics(collaboration);
+    }
+  };
+}
+
+module.exports = { createHierarchyAttacher };

package/src/agentMonitor/sessionFiles.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const MAX_FILES_PER_PROVIDER = 80;
+const MAX_JSONL_BYTES = 12 * 1024 * 1024;
+
+function safeStat(file) {
+  try { return fs.statSync(file); } catch (_missingOrUnreadableFile) { return null; }
+}
+
+function readJson(file, fallback = null) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch (_missingOrPartialJson) { return fallback; }
+}
+
+function parseJsonText(text) {
+  try { return JSON.parse(text); } catch (_plainTextPayload) { return null; }
+}
+
+function readJsonLines(file, maxBytes = MAX_JSONL_BYTES) {
+  const stat = safeStat(file);
+  if (!stat || !stat.isFile()) return { rows: [], truncated: false };
+  const start = Math.max(0, stat.size - maxBytes);
+  const length = stat.size - start;
+  const fd = fs.openSync(file, 'r');
+  const buffer = Buffer.alloc(length);
+  let headerLine = '';
+  try {
+    fs.readSync(fd, buffer, 0, length, start);
+    if (start > 0) {
+      const headLength = Math.min(stat.size, 2 * 1024 * 1024);
+      const head = Buffer.alloc(headLength);
+      fs.readSync(fd, head, 0, headLength, 0);
+      const newline = head.indexOf(10);
+      if (newline >= 0) {
+        headerLine = head.subarray(0, newline).toString('utf8').replace(/\r$/, '');
+      }
+    }
+  } finally {
+    fs.closeSync(fd);
+  }
+  let text = buffer.toString('utf8');
+  if (start > 0) {
+    const newline = text.indexOf('\n');
+    text = newline >= 0 ? text.slice(newline + 1) : '';
+  }
+  const rows = [];
+  for (const line of text.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    const row = parseJsonText(line);
+    if (row) rows.push(row);
+  }
+  if (headerLine) {
+    const header = parseJsonText(headerLine);
+    if (header && header.type === 'session_meta') rows.unshift(header);
+  }
+  return { rows, truncated: start > 0 };
+}
+
+function walkRecent(root, predicate, max = MAX_FILES_PER_PROVIDER, maxDepth = 6) {
+  if (!root || !fs.existsSync(root)) return [];
+  const out = [];
+  const stack = [{ dir: root, depth: 0 }];
+  while (stack.length) {
+    const { dir, depth } = stack.pop();
+    let entries = [];
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch (_unreadableDirectory) { continue; }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory() && depth < maxDepth) stack.push({ dir: full, depth: depth + 1 });
+      if (!entry.isFile() || !predicate(full, entry.name)) continue;
+      const stat = safeStat(full);
+      if (stat) out.push({ file: full, mtimeMs: stat.mtimeMs, size: stat.size });
+    }
+  }
+  return out.sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, max);
+}
+
+module.exports = {
+  MAX_FILES_PER_PROVIDER,
+  readJson,
+  readJsonLines,
+  safeStat,
+  walkRecent,
+};