olakai-cli 0.1.15 → 0.2.1

package/dist/index.js

@@ -2183,9 +2183,197 @@ function registerActivityCommand(program2) {
 }
 
 // src/commands/monitor.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import * as readline from "readline";
+
+// src/commands/monitor-transcript.ts
+var SKILL_REGEX = /^\/([\w-]+)(?:\s|$)/;
+function detectSkill(userMessage) {
+  if (typeof userMessage !== "string") return void 0;
+  const trimmed = userMessage.trimStart();
+  if (!trimmed) return void 0;
+  const match = SKILL_REGEX.exec(trimmed);
+  if (!match) return void 0;
+  return match[1];
+}
+function extractTextContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const block of content) {
+    if (block?.type === "text" && typeof block.text === "string") {
+      parts.push(block.text);
+    }
+  }
+  return parts.join("\n").trim();
+}
+function isMetaUserMessage(line, text) {
+  if (line.isMeta === true) return true;
+  if (!text) return true;
+  return text.includes("<command-name>") || text.includes("<local-command-caveat>") || text.includes("<command-message>");
+}
+function parseTimestamp(ts) {
+  if (typeof ts !== "string" || !ts) return NaN;
+  return Date.parse(ts);
+}
+function isCompactionEntry(line) {
+  if (line.type !== "system") return false;
+  const subtype = line.subtype ?? "";
+  return subtype === "compact_boundary" || subtype === "pre_compact" || subtype === "post_compact" || /compact/i.test(subtype);
+}
+function parseTranscript(raw) {
+  const empty = {
+    prompt: "",
+    response: "",
+    tokens: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    modelName: null,
+    numTurns: 0
+  };
+  if (!raw) return empty;
+  const lines = raw.split("\n");
+  let lastUserText = "";
+  let lastUserTimestamp = NaN;
+  let lastUserTimestampRaw;
+  let lastAssistantText = "";
+  let lastAssistantTimestamp = NaN;
+  let lastAssistantModel = null;
+  let lastAssistantInputTokens = 0;
+  let lastAssistantOutputTokens = 0;
+  let numTurns = 0;
+  let currentTurnUserTimestamp = NaN;
+  for (const rawLine of lines) {
+    if (!rawLine) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(rawLine);
+    } catch {
+      continue;
+    }
+    if (isCompactionEntry(parsed)) continue;
+    if (parsed.isSidechain === true) continue;
+    if (parsed.type === "user" && parsed.message) {
+      const text = extractTextContent(parsed.message.content);
+      if (isMetaUserMessage(parsed, text)) continue;
+      lastUserText = text;
+      lastUserTimestamp = parseTimestamp(parsed.timestamp);
+      currentTurnUserTimestamp = lastUserTimestamp;
+      lastUserTimestampRaw = typeof parsed.timestamp === "string" && parsed.timestamp ? parsed.timestamp : void 0;
+    } else if (parsed.type === "assistant" && parsed.message) {
+      const text = extractTextContent(parsed.message.content);
+      numTurns += 1;
+      if (text) lastAssistantText = text;
+      if (typeof parsed.message.model === "string") {
+        lastAssistantModel = parsed.message.model;
+      }
+      const usage = parsed.message.usage;
+      if (usage) {
+        const input = (usage.input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0);
+        const output = usage.output_tokens ?? 0;
+        lastAssistantInputTokens = input;
+        lastAssistantOutputTokens = output;
+      }
+      const ts = parseTimestamp(parsed.timestamp);
+      if (!Number.isNaN(ts)) {
+        lastAssistantTimestamp = ts;
+      }
+    }
+  }
+  const result = {
+    prompt: lastUserText,
+    response: lastAssistantText,
+    tokens: lastAssistantInputTokens + lastAssistantOutputTokens,
+    inputTokens: lastAssistantInputTokens,
+    outputTokens: lastAssistantOutputTokens,
+    modelName: lastAssistantModel,
+    numTurns
+  };
+  if (!Number.isNaN(currentTurnUserTimestamp) && !Number.isNaN(lastAssistantTimestamp) && lastAssistantTimestamp >= currentTurnUserTimestamp) {
+    result.latencyMs = Math.round(
+      lastAssistantTimestamp - currentTurnUserTimestamp
+    );
+  }
+  const skill = detectSkill(lastUserText);
+  if (skill) {
+    result.skill = skill;
+  }
+  if (lastUserTimestampRaw) {
+    result.userTurnTimestamp = lastUserTimestampRaw;
+  }
+  return result;
+}
+
+// src/commands/monitor-state.ts
 import * as fs2 from "fs";
+import * as os2 from "os";
 import * as path2 from "path";
-import * as readline from "readline";
+var STATE_DIR_SEGMENTS = [".olakai", "monitor-state"];
+function getStateDir(homeDir) {
+  return path2.join(homeDir, ...STATE_DIR_SEGMENTS);
+}
+function getStateFile(sessionId, homeDir) {
+  return path2.join(getStateDir(homeDir), `${sessionId}.json`);
+}
+var debugLogger = null;
+function setDebugLogger(logger) {
+  debugLogger = logger;
+}
+function log(label, data) {
+  if (debugLogger) {
+    try {
+      debugLogger(label, data);
+    } catch {
+    }
+  }
+}
+function loadSessionState(sessionId, homeDir = os2.homedir()) {
+  if (!sessionId) return null;
+  const filePath = getStateFile(sessionId, homeDir);
+  try {
+    if (!fs2.existsSync(filePath)) return null;
+    const raw = fs2.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed?.lastUserTimestamp !== "string" || typeof parsed?.lastReportedAt !== "string" || typeof parsed?.numTurnsAtLastReport !== "number") {
+      return null;
+    }
+    return {
+      lastUserTimestamp: parsed.lastUserTimestamp,
+      lastReportedAt: parsed.lastReportedAt,
+      numTurnsAtLastReport: parsed.numTurnsAtLastReport
+    };
+  } catch (err) {
+    log("state-load-failed", {
+      sessionId,
+      error: err.message
+    });
+    return null;
+  }
+}
+function saveSessionState(sessionId, state, homeDir = os2.homedir()) {
+  if (!sessionId) return;
+  const dir = getStateDir(homeDir);
+  const filePath = getStateFile(sessionId, homeDir);
+  try {
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    fs2.writeFileSync(filePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+  } catch (err) {
+    log("state-save-failed", {
+      sessionId,
+      error: err.message
+    });
+  }
+}
+function shouldReportTurn(existing, currentUserTimestamp) {
+  if (!currentUserTimestamp) return true;
+  if (!existing) return true;
+  return existing.lastUserTimestamp !== currentUserTimestamp;
+}
+
+// src/commands/monitor.ts
 var CLAUDE_DIR = ".claude";
 var SETTINGS_FILE = "settings.json";
 var MONITOR_CONFIG_FILE = "olakai-monitor.json";
@@ -2201,8 +2389,36 @@ var HOOK_DEFINITIONS = {
         }
       ]
     }
+  ],
+  SubagentStop: [
+    {
+      matcher: "",
+      hooks: [
+        {
+          type: "command",
+          command: "olakai monitor hook subagent-stop"
+        }
+      ]
+    }
   ]
 };
+function mergeHooksSettings(existing, definitions = HOOK_DEFINITIONS) {
+  const merged = {
+    ...existing ?? {}
+  };
+  for (const [event, defaultEntries] of Object.entries(definitions)) {
+    const existingEntries = merged[event] ?? [];
+    const hasOlakaiHook = existingEntries.some(
+      (e) => e.hooks.some((h) => h.command.includes(OLAKAI_HOOK_MARKER))
+    );
+    if (hasOlakaiHook) {
+      merged[event] = existingEntries;
+    } else {
+      merged[event] = [...existingEntries, ...defaultEntries];
+    }
+  }
+  return merged;
+}
 function prompt(question) {
   const rl = readline.createInterface({
     input: process.stdin,
@@ -2218,39 +2434,55 @@ function prompt(question) {
 function findProjectRoot(startDir) {
   let dir = startDir ?? process.cwd();
   while (true) {
-    if (fs2.existsSync(path2.join(dir, CLAUDE_DIR))) {
+    if (fs3.existsSync(path3.join(dir, CLAUDE_DIR))) {
       return dir;
     }
-    const parent = path2.dirname(dir);
+    const parent = path3.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return startDir ?? process.cwd();
 }
+function findConfiguredProjectRoot(startDir) {
+  let dir = startDir ?? process.cwd();
+  while (true) {
+    if (fs3.existsSync(path3.join(dir, CLAUDE_DIR, MONITOR_CONFIG_FILE))) {
+      return dir;
+    }
+    const parent = path3.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function resolveProjectRootFromPayload(eventData, fallbackCwd) {
+  const payloadCwd = typeof eventData.cwd === "string" && eventData.cwd.trim() ? eventData.cwd : fallbackCwd;
+  return findConfiguredProjectRoot(payloadCwd);
+}
 function getClaudeDir(projectRoot) {
-  return path2.join(projectRoot, CLAUDE_DIR);
+  return path3.join(projectRoot, CLAUDE_DIR);
 }
 function getSettingsPath(projectRoot) {
-  return path2.join(getClaudeDir(projectRoot), SETTINGS_FILE);
+  return path3.join(getClaudeDir(projectRoot), SETTINGS_FILE);
 }
 function getMonitorConfigPath(projectRoot) {
-  return path2.join(getClaudeDir(projectRoot), MONITOR_CONFIG_FILE);
+  return path3.join(getClaudeDir(projectRoot), MONITOR_CONFIG_FILE);
 }
 function readJsonFile(filePath) {
   try {
-    if (!fs2.existsSync(filePath)) return null;
-    const content = fs2.readFileSync(filePath, "utf-8");
+    if (!fs3.existsSync(filePath)) return null;
+    const content = fs3.readFileSync(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function writeJsonFile(filePath, data) {
-  const dir = path2.dirname(filePath);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
+  const dir = path3.dirname(filePath);
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
   }
-  fs2.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  fs3.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
 function loadMonitorConfig(projectRoot) {
   const root = projectRoot ?? findProjectRoot();
@@ -2290,7 +2522,7 @@ async function initCommand() {
   }
   console.log("Setting up Claude Code monitoring for this workspace...\n");
   const projectRoot = process.cwd();
-  const dirName = path2.basename(projectRoot);
+  const dirName = path3.basename(projectRoot);
   let agent;
   const choice = await prompt(
     "Create a new agent or use an existing one? (new/existing) [new]: "
@@ -2341,21 +2573,12 @@ Select agent (1-${agents.length}): `);
     }
   }
   const claudeDir = getClaudeDir(projectRoot);
-  if (!fs2.existsSync(claudeDir)) {
-    fs2.mkdirSync(claudeDir, { recursive: true });
+  if (!fs3.existsSync(claudeDir)) {
+    fs3.mkdirSync(claudeDir, { recursive: true });
   }
   const settingsPath = getSettingsPath(projectRoot);
   const existingSettings = readJsonFile(settingsPath) ?? {};
-  const mergedHooks = {
-    ...existingSettings.hooks ?? {}
-  };
-  for (const [event, entries] of Object.entries(HOOK_DEFINITIONS)) {
-    const existing = mergedHooks[event] ?? [];
-    const filtered = existing.filter(
-      (e) => !e.hooks.some((h) => h.command.includes(OLAKAI_HOOK_MARKER))
-    );
-    mergedHooks[event] = [...filtered, ...entries];
-  }
+  const mergedHooks = mergeHooksSettings(existingSettings.hooks);
   const updatedSettings = {
     ...existingSettings,
     hooks: mergedHooks
@@ -2372,7 +2595,7 @@ Select agent (1-${agents.length}): `);
   };
   const monitorConfigPath = getMonitorConfigPath(projectRoot);
   writeJsonFile(monitorConfigPath, monitorConfig);
-  fs2.chmodSync(monitorConfigPath, 384);
+  fs3.chmodSync(monitorConfigPath, 384);
   console.log("");
   console.log(`\u2713 Agent "${agent.name}" configured (ID: ${agent.id})`);
   if (agent.apiKey?.key) {
@@ -2416,26 +2639,10 @@ function debugLog(label, data) {
     const logPath = `/tmp/olakai-monitor-debug-${process.pid}.log`;
     const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${label}: ${typeof data === "string" ? data : JSON.stringify(data, null, 2)}
 `;
-    fs2.appendFileSync(logPath, line, "utf-8");
+    fs3.appendFileSync(logPath, line, "utf-8");
   } catch {
   }
 }
-function extractTextContent(content) {
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return "";
-  const parts = [];
-  for (const block of content) {
-    if (block?.type === "text" && typeof block.text === "string") {
-      parts.push(block.text);
-    }
-  }
-  return parts.join("\n").trim();
-}
-function isMetaUserMessage(line, text) {
-  if (line.isMeta === true) return true;
-  if (!text) return true;
-  return text.includes("<command-name>") || text.includes("<local-command-caveat>") || text.includes("<command-message>");
-}
 function extractFromTranscript(transcriptPath) {
   const empty = {
     prompt: "",
@@ -2449,7 +2656,7 @@ function extractFromTranscript(transcriptPath) {
   if (!transcriptPath) return empty;
   let raw;
   try {
-    raw = fs2.readFileSync(transcriptPath, "utf-8");
+    raw = fs3.readFileSync(transcriptPath, "utf-8");
   } catch (err) {
     debugLog("transcript-read-failed", {
       transcriptPath,
@@ -2457,58 +2664,25 @@ function extractFromTranscript(transcriptPath) {
     });
     return empty;
   }
-  const lines = raw.split("\n");
-  let lastUserText = "";
-  let lastAssistantText = "";
-  let lastAssistantModel = null;
-  let lastAssistantInputTokens = 0;
-  let lastAssistantOutputTokens = 0;
-  let numTurns = 0;
-  for (const rawLine of lines) {
-    if (!rawLine) continue;
-    let parsed;
-    try {
-      parsed = JSON.parse(rawLine);
-    } catch {
-      continue;
-    }
-    if (parsed.isSidechain === true) continue;
-    if (parsed.type === "user" && parsed.message) {
-      const text = extractTextContent(parsed.message.content);
-      if (isMetaUserMessage(parsed, text)) continue;
-      lastUserText = text;
-    } else if (parsed.type === "assistant" && parsed.message) {
-      const text = extractTextContent(parsed.message.content);
-      numTurns += 1;
-      if (text) lastAssistantText = text;
-      if (typeof parsed.message.model === "string") {
-        lastAssistantModel = parsed.message.model;
-      }
-      const usage = parsed.message.usage;
-      if (usage) {
-        const input = (usage.input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0);
-        const output = usage.output_tokens ?? 0;
-        lastAssistantInputTokens = input;
-        lastAssistantOutputTokens = output;
-      }
+  return parseTranscript(raw);
+}
+function extractSubagentName(event) {
+  const candidates = [
+    event.agent_name,
+    event.subagent_type,
+    event.agent_type,
+    event.tool_input?.subagent_type
+  ];
+  for (const value of candidates) {
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
     }
   }
-  return {
-    prompt: lastUserText,
-    response: lastAssistantText,
-    tokens: lastAssistantInputTokens + lastAssistantOutputTokens,
-    inputTokens: lastAssistantInputTokens,
-    outputTokens: lastAssistantOutputTokens,
-    modelName: lastAssistantModel,
-    numTurns
-  };
+  return void 0;
 }
 async function hookCommand(event) {
+  setDebugLogger(debugLog);
   try {
-    const config = loadMonitorConfig();
-    if (!config) {
-      return;
-    }
     const stdinData = await readStdin(3e3);
     debugLog("stdin-raw", stdinData);
     let eventData = {};
@@ -2517,15 +2691,42 @@ async function hookCommand(event) {
         eventData = JSON.parse(stdinData);
       } catch {
         debugLog("stdin-parse-failed", stdinData);
-        return;
       }
     }
     debugLog("event-parsed", { event, eventData });
+    const projectRoot = resolveProjectRootFromPayload(
+      eventData,
+      process.cwd()
+    );
+    if (!projectRoot) {
+      debugLog("config-not-found", {
+        startDir: typeof eventData.cwd === "string" && eventData.cwd.trim() ? eventData.cwd : process.cwd()
+      });
+      return;
+    }
+    const config = loadMonitorConfig(projectRoot);
+    if (!config) {
+      debugLog("config-load-failed", { projectRoot });
+      return;
+    }
     const payload = buildPayload(event, eventData, config);
     if (!payload) {
       return;
     }
     debugLog("payload-built", payload);
+    const sessionId = typeof eventData.session_id === "string" && eventData.session_id || void 0;
+    const extracted = extractFromTranscript(eventData.transcript_path);
+    const userTurnTimestamp = extracted.userTurnTimestamp;
+    if (sessionId) {
+      const existingState = loadSessionState(sessionId);
+      if (!shouldReportTurn(existingState, userTurnTimestamp)) {
+        debugLog("turn-dedup-skip", {
+          sessionId,
+          userTurnTimestamp
+        });
+        return;
+      }
+    }
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 5e3);
     try {
@@ -2545,6 +2746,18 @@ async function hookCommand(event) {
     } finally {
       clearTimeout(timeoutId);
     }
+    if (sessionId && userTurnTimestamp) {
+      saveSessionState(sessionId, {
+        lastUserTimestamp: userTurnTimestamp,
+        lastReportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        numTurnsAtLastReport: extracted.numTurns
+      });
+      debugLog("state-saved", {
+        sessionId,
+        userTurnTimestamp,
+        numTurns: extracted.numTurns
+      });
+    }
   } catch (err) {
     debugLog("hook-exception", err.message);
   }
@@ -2552,27 +2765,43 @@ async function hookCommand(event) {
 function buildPayload(event, eventData, config) {
   const sessionId = eventData.session_id ?? `claude-code-${Date.now()}`;
   switch (event) {
-    case "stop": {
+    case "stop":
+    case "subagent-stop": {
       const extracted = extractFromTranscript(eventData.transcript_path);
+      const isSubagent = event === "subagent-stop";
+      const customData = {
+        hookEvent: eventData.hook_event_name ?? (isSubagent ? "SubagentStop" : "Stop"),
+        sessionId,
+        transcriptPath: eventData.transcript_path ?? "",
+        cwd: eventData.cwd ?? "",
+        stopHookActive: eventData.stop_hook_active ?? false,
+        inputTokens: extracted.inputTokens,
+        outputTokens: extracted.outputTokens,
+        numTurns: extracted.numTurns
+      };
+      if (typeof extracted.latencyMs === "number") {
+        customData.latencyMs = extracted.latencyMs;
+      }
+      if (isSubagent) {
+        const subagent = extractSubagentName(eventData);
+        if (subagent) {
+          customData.subagent = subagent;
+        }
+      } else if (extracted.skill) {
+        customData.skill = extracted.skill;
+      }
+      const payloadAssistant = eventData.last_assistant_message;
+      const response = typeof payloadAssistant === "string" && payloadAssistant.trim() ? payloadAssistant : extracted.response;
       return {
         prompt: extracted.prompt,
-        response: extracted.response,
+        response,
         chatId: sessionId,
         // Top-level source so the backend ExternalPromptRequestSchema
         // picks it up (matches regex ^[a-z0-9_-]+$).
         source: config.source,
         modelName: extracted.modelName ?? void 0,
         tokens: extracted.tokens,
-        customData: {
-          hookEvent: eventData.hook_event_name ?? "Stop",
-          sessionId,
-          transcriptPath: eventData.transcript_path ?? "",
-          cwd: eventData.cwd ?? "",
-          stopHookActive: eventData.stop_hook_active ?? false,
-          inputTokens: extracted.inputTokens,
-          outputTokens: extracted.outputTokens,
-          numTurns: extracted.numTurns
-        }
+        customData
       };
     }
     default:
@@ -2672,8 +2901,8 @@ async function disableCommand(options) {
   }
   if (!options.keepConfig) {
     const configPath = getMonitorConfigPath(projectRoot);
-    if (fs2.existsSync(configPath)) {
-      fs2.unlinkSync(configPath);
+    if (fs3.existsSync(configPath)) {
+      fs3.unlinkSync(configPath);
       console.log(`\u2713 Monitor config removed (${CLAUDE_DIR}/${MONITOR_CONFIG_FILE})`);
     }
   } else {