@kairyou/agent-tools 0.12.0 → 0.13.0

package/dist/log/hook.mjs

@@ -0,0 +1,1581 @@
+#!/usr/bin/env node
+
+// integrations/log/hook.mjs
+import { spawnSync } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+// node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += "\n";
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "	";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += "\n";
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      // tokens: []{}:,
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      // strings
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      // comments
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      // numbers
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      // found a minus, followed by a number so
+      // we fall through to proceed with scanning
+      // numbers
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      // literals and unknown symbols
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\n" + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r\n" + " ".repeat(index);
+    })
+  },
+  "	": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\n" + "	".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + "	".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r\n" + "	".repeat(index);
+    })
+  }
+};
+
+// node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentProperty = null;
+  let currentParent = [];
+  const previousParents = [];
+  function onValue(value) {
+    if (Array.isArray(currentParent)) {
+      currentParent.push(value);
+    } else if (currentProperty !== null) {
+      currentParent[currentProperty] = value;
+    }
+  }
+  const visitor = {
+    onObjectBegin: () => {
+      const object = {};
+      onValue(object);
+      previousParents.push(currentParent);
+      currentParent = object;
+      currentProperty = null;
+    },
+    onObjectProperty: (name) => {
+      currentProperty = name;
+    },
+    onObjectEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onArrayBegin: () => {
+      const array = [];
+      onValue(array);
+      previousParents.push(currentParent);
+      currentParent = array;
+      currentProperty = null;
+    },
+    onArrayEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onLiteralValue: onValue,
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  return currentParent[0];
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(
+            14
+            /* ParseErrorCode.InvalidUnicode */
+          );
+          break;
+        case 5:
+          handleError(
+            15
+            /* ParseErrorCode.InvalidEscapeCharacter */
+          );
+          break;
+        case 3:
+          handleError(
+            13
+            /* ParseErrorCode.UnexpectedEndOfNumber */
+          );
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(
+              11
+              /* ParseErrorCode.UnexpectedEndOfComment */
+            );
+          }
+          break;
+        case 2:
+          handleError(
+            12
+            /* ParseErrorCode.UnexpectedEndOfString */
+          );
+          break;
+        case 6:
+          handleError(
+            16
+            /* ParseErrorCode.InvalidCharacter */
+          );
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(
+              10
+              /* ParseErrorCode.InvalidCommentToken */
+            );
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(
+            1
+            /* ParseErrorCode.InvalidSymbol */
+          );
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(
+            2
+            /* ParseErrorCode.InvalidNumberFormat */
+          );
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+    } else {
+      handleError(5, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [
+        2
+        /* SyntaxKind.CloseBraceToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [
+          4,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [
+        4
+        /* SyntaxKind.CloseBracketToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+
+// node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parse2 = parse;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+
+// integrations/log/hook.mjs
+var MAX_SNAPSHOT_BYTES = 512 * 1024;
+var MIN_RESULT_SUMMARY_LENGTH = 24;
+var DAILY_ITEM_MAX_CHARS = 160;
+var INSTALL_ROOT = process.env.AGENT_TOOLS_HOME || path.join(os.homedir(), ".agent-tools");
+var CACHE_ROOT = path.join(INSTALL_ROOT, "cache", "log");
+async function main() {
+  const rawInput = await readStdin();
+  if (!rawInput.trim()) return;
+  let hookInput;
+  try {
+    hookInput = JSON.parse(stripBom(rawInput));
+  } catch (error) {
+    console.error(`[agent-tools log] Failed to parse hook input: ${error.message}`);
+    return;
+  }
+  const eventName = getEventName(hookInput);
+  if (!["UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop"].includes(eventName)) {
+    return;
+  }
+  const config = await loadLogConfig();
+  if (!config.enabled) return;
+  const cwd = eventCwd(hookInput);
+  const scope = matchScope(config, cwd);
+  if (config.projects.length > 0 && !scope) return;
+  const effective = scope || config;
+  const scopeKey = `${effective.format}|${pathKey(effective.output)}`;
+  const now = /* @__PURE__ */ new Date();
+  const day = formatLocalDate(now);
+  const statePath = path.join(CACHE_ROOT, `${day}.state.json`);
+  const snapshotsRoot = path.join(CACHE_ROOT, `${day}.snapshots`);
+  await fs.mkdir(CACHE_ROOT, { recursive: true });
+  await cleanupCache(day);
+  const state = await loadState(statePath, day);
+  await handleEvent(state, hookInput, { now, snapshotsRoot, effective, scopeKey });
+  await writeFileAtomic(statePath, `${JSON.stringify(state, null, 2)}
+`);
+  if (effective.format === "detailed") {
+    const report = await renderDetailedReport(state, {
+      snapshotsRoot,
+      language: effective.language,
+      scopeKey
+    });
+    await fs.mkdir(effective.output, { recursive: true });
+    await writeFileAtomic(path.join(effective.output, `${day}.md`), report);
+  } else {
+    await updateDailyFile(effective.output, day, buildDailyItems(state, scopeKey));
+  }
+}
+function eventCwd(input) {
+  return firstNonEmpty(input?.cwd, input?.workspace, input?.project_dir) || process.cwd();
+}
+async function loadLogConfig() {
+  let parsed = {};
+  try {
+    const raw = await fs.readFile(path.join(INSTALL_ROOT, "config.jsonc"), "utf8");
+    parsed = parse2(stripBom(raw), [], { allowTrailingComma: true }) || {};
+  } catch {
+  }
+  const section = isPlainObject(parsed.log) ? parsed.log : {};
+  const enabled = section.enabled !== false;
+  const format2 = pickFormat(section.format, "daily");
+  const language = pickLanguage(section.language, "zh");
+  const output = pickOutput(section.output, format2, defaultOutput(format2));
+  const projects = [];
+  if (Array.isArray(section.projects)) {
+    for (const item of section.projects) {
+      const entry = typeof item === "string" ? { path: item } : isPlainObject(item) ? item : null;
+      if (!entry || typeof entry.path !== "string" || !entry.path.trim()) continue;
+      const scopeFormat = pickFormat(entry.format, format2);
+      projects.push({
+        path: path.resolve(expandHome(entry.path.trim())),
+        format: scopeFormat,
+        language: pickLanguage(entry.language, language),
+        // An entry that switches format without naming an output cannot reuse
+        // the top-level one (file vs directory), so it gets the built-in default.
+        output: pickOutput(entry.output, scopeFormat, scopeFormat === format2 ? output : defaultOutput(scopeFormat))
+      });
+    }
+  }
+  return { enabled, format: format2, language, output, projects };
+}
+function pickFormat(value, fallback) {
+  return value === "detailed" || value === "daily" ? value : fallback;
+}
+function pickLanguage(value, fallback) {
+  return value === "en" || value === "zh" ? value : fallback;
+}
+function defaultOutput(format2) {
+  return path.join(INSTALL_ROOT, "logs", format2 === "detailed" ? "ai-log" : "ai-log.md");
+}
+function pickOutput(value, format2, fallback) {
+  return typeof value === "string" && value.trim() ? path.resolve(expandHome(value.trim())) : fallback;
+}
+function pathKey(value) {
+  const normalized = normalizePath(path.resolve(value));
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function matchScope(config, cwd) {
+  const key = pathKey(cwd);
+  let best = null;
+  for (const entry of config.projects) {
+    const entryKey = pathKey(entry.path);
+    if (key !== entryKey && !key.startsWith(`${entryKey}/`)) continue;
+    if (!best || entryKey.length > pathKey(best.path).length) best = entry;
+  }
+  return best;
+}
+async function handleEvent(state, input, context) {
+  const timestamp = formatLocalDateTime(context.now);
+  const eventName = getEventName(input);
+  const sessionId = getSessionId(input);
+  const session = ensureSession(state, sessionId, timestamp);
+  session.last_time = timestamp;
+  if (eventName === "UserPromptSubmit") {
+    session.turns.push(
+      createTurn(session, timestamp, getPromptText(input), resolveProjectLabel(input), context.scopeKey)
+    );
+    return;
+  }
+  const turn = ensureCurrentTurn(session, timestamp, resolveProjectLabel(input), context.scopeKey);
+  turn.last_time = timestamp;
+  if (eventName === "PreToolUse") {
+    if (context.effective.format === "detailed") {
+      await captureBaselineSnapshot(turn, sessionId, input, {
+        timestamp,
+        snapshotsRoot: context.snapshotsRoot
+      });
+    }
+    return;
+  }
+  if (eventName === "Stop") {
+    const summary = excerptMultiline(getOutcomeText(input), 900);
+    if (summary) turn.result_summary = summary;
+    return;
+  }
+  recordToolUse(turn, input, { timestamp });
+}
+function resolveProjectLabel(input) {
+  const cwd = eventCwd(input);
+  const result = spawnSync("git", ["-C", cwd, "rev-parse", "--show-toplevel"], {
+    encoding: "utf8",
+    windowsHide: true
+  });
+  const root = result.status === 0 ? result.stdout.trim() : "";
+  return path.basename(root || cwd);
+}
+async function cleanupCache(day) {
+  let entries = [];
+  try {
+    entries = await fs.readdir(CACHE_ROOT, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  await Promise.all(
+    entries.map(async (entry) => {
+      const isState = entry.isFile() && /^\d{4}-\d{2}-\d{2}\.state\.json$/.test(entry.name);
+      const isSnapshots = entry.isDirectory() && /^\d{4}-\d{2}-\d{2}\.snapshots$/.test(entry.name);
+      if (!isState && !isSnapshots || entry.name.startsWith(day)) return;
+      try {
+        await fs.rm(path.join(CACHE_ROOT, entry.name), { recursive: true, force: true });
+      } catch {
+      }
+    })
+  );
+}
+async function loadState(statePath, day) {
+  try {
+    const parsed = JSON.parse(await fs.readFile(statePath, "utf8"));
+    if (isPlainObject(parsed) && parsed.date === day && isPlainObject(parsed.sessions)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return { date: day, sessions: {} };
+}
+function ensureSession(state, sessionId, timestamp) {
+  if (!state.sessions[sessionId]) {
+    state.sessions[sessionId] = { first_time: timestamp, last_time: timestamp, turns: [] };
+  }
+  return state.sessions[sessionId];
+}
+function ensureCurrentTurn(session, timestamp, project, scopeKey) {
+  if (!Array.isArray(session.turns)) session.turns = [];
+  const currentTurn = session.turns[session.turns.length - 1];
+  if (currentTurn) return currentTurn;
+  const fallbackTurn = createTurn(session, timestamp, "", project, scopeKey);
+  session.turns.push(fallbackTurn);
+  return fallbackTurn;
+}
+function createTurn(session, timestamp, requestText, project, scopeKey) {
+  const turnIndex = Array.isArray(session.turns) ? session.turns.length + 1 : 1;
+  return {
+    turn_id: `turn-${turnIndex}-${simpleHash(`${timestamp}-${requestText}`).slice(0, 8)}`,
+    first_time: timestamp,
+    last_time: timestamp,
+    project: project || "",
+    scope: scopeKey || "",
+    request_text: excerptMultiline(requestText || "", 1600),
+    result_summary: "",
+    bash_commands: 0,
+    verification_commands: 0,
+    files: {}
+  };
+}
+function ensureTurnFile(turn, fileKey, relativePath, absolutePath, timestamp) {
+  if (!turn.files[fileKey]) {
+    turn.files[fileKey] = {
+      rel: relativePath,
+      abs: absolutePath,
+      writes: 0,
+      edits: 0,
+      first_time: timestamp,
+      last_time: timestamp,
+      snapshot_kind: ""
+    };
+  }
+  return turn.files[fileKey];
+}
+function recordToolUse(turn, input, context) {
+  const toolName = getToolName(input);
+  if (toolName === "Bash") {
+    const kind = classifyCommand(getShellCommand(input));
+    turn.bash_commands += 1;
+    if (["test", "lint", "typecheck", "build", "format"].includes(kind)) {
+      turn.verification_commands += 1;
+    }
+    return;
+  }
+  if (!["Write", "Edit", "MultiEdit"].includes(toolName)) return;
+  const located = locateToolFile(input);
+  if (!located) return;
+  const turnFile = ensureTurnFile(turn, located.key, located.rel, located.abs, context.timestamp);
+  turnFile.last_time = context.timestamp;
+  if (!turnFile.snapshot_kind) turnFile.snapshot_kind = "unknown";
+  if (toolName === "Write") turnFile.writes += 1;
+  else turnFile.edits += 1;
+}
+function locateToolFile(input) {
+  const rawPath = getToolFilePath(input);
+  if (!rawPath) return null;
+  const cwd = firstNonEmpty(input?.cwd, input?.workspace, input?.project_dir) || process.cwd();
+  const abs = normalizePath(path.resolve(cwd, rawPath));
+  const cwdNormalized = normalizePath(path.resolve(cwd));
+  const rel = abs.toLowerCase().startsWith(`${cwdNormalized.toLowerCase()}/`) ? abs.slice(cwdNormalized.length + 1) : abs;
+  const key = process.platform === "win32" ? abs.toLowerCase() : abs;
+  return { key, rel, abs };
+}
+async function captureBaselineSnapshot(turn, sessionId, input, context) {
+  const toolName = getToolName(input);
+  if (!["Write", "Edit", "MultiEdit"].includes(toolName)) return;
+  const located = locateToolFile(input);
+  if (!located) return;
+  const turnFile = ensureTurnFile(turn, located.key, located.rel, located.abs, context.timestamp);
+  if (turnFile.snapshot_kind) return;
+  turnFile.snapshot_kind = await createSnapshotFile(
+    buildSnapshotKey(sessionId, turn.turn_id),
+    located,
+    context.snapshotsRoot
+  );
+}
+async function createSnapshotFile(snapshotKey, located, snapshotsRoot) {
+  let stats;
+  try {
+    stats = await fs.stat(located.abs);
+  } catch (error) {
+    return error?.code === "ENOENT" ? "missing" : "unknown";
+  }
+  if (!stats.isFile()) return "unknown";
+  if (stats.size > MAX_SNAPSHOT_BYTES) return "large";
+  let buffer;
+  try {
+    buffer = await fs.readFile(located.abs);
+  } catch {
+    return "unknown";
+  }
+  if (buffer.includes(0)) return "binary";
+  const snapshotPath = getSnapshotPath(snapshotsRoot, snapshotKey, located);
+  await fs.mkdir(path.dirname(snapshotPath), { recursive: true });
+  await fs.writeFile(snapshotPath, buffer);
+  return "text";
+}
+function getSnapshotPath(snapshotsRoot, snapshotKey, located) {
+  return path.join(snapshotsRoot, sanitizeDirName(snapshotKey), `${simpleHash(located.key)}-${path.basename(located.abs)}`);
+}
+function buildSnapshotKey(sessionId, turnId) {
+  return `${sessionId}-${turnId}`;
+}
+function sanitizeDirName(value) {
+  const normalized = String(value || "").toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return `${normalized || "session"}-${simpleHash(value).slice(0, 8)}`;
+}
+function buildDailyItems(state, scopeKey) {
+  const items = [];
+  for (const session of orderedSessions(state)) {
+    for (const turn of session.turns || []) {
+      if (String(turn.scope || "") !== scopeKey) continue;
+      const text = dailyItemText(turn);
+      if (!text) continue;
+      items.push({ first_time: turn.first_time, project: turn.project || "", text });
+    }
+  }
+  items.sort((a, b) => String(a.first_time).localeCompare(String(b.first_time)));
+  return items;
+}
+function dailyItemText(turn) {
+  const request = String(turn.request_text || "");
+  const outcome = String(turn.result_summary || "");
+  if (!hasSubstantiveTurn(request, outcome) || isTrivialTurn(request, outcome)) return "";
+  const source = outcome || request;
+  const firstLine = source.split("\n").map((line) => line.replace(/^[#>*\-\s`]+/, "").trim()).find((line) => line.length > 0);
+  if (!firstLine) return "";
+  return firstLine.length > DAILY_ITEM_MAX_CHARS ? `${firstLine.slice(0, DAILY_ITEM_MAX_CHARS - 3)}...` : firstLine;
+}
+async function updateDailyFile(outputFile, day, items) {
+  if (items.length === 0) return;
+  const lines = items.map(
+    (item, index) => `  ${index + 1}. ${item.project ? `${item.project}: ` : ""}${item.text}`
+  );
+  const block = [`<!-- log:${day}:start -->`, ...lines, `<!-- log:${day}:end -->`];
+  let current = "";
+  try {
+    current = await fs.readFile(outputFile, "utf8");
+  } catch {
+  }
+  const eol = current.includes("\r\n") ? "\r\n" : "\n";
+  const fileLines = current ? current.split(/\r?\n/) : [];
+  const startMarker = `<!-- log:${day}:start -->`;
+  const endMarker = `<!-- log:${day}:end -->`;
+  const startIndex = fileLines.findIndex((line) => line.trim() === startMarker);
+  const endIndex = fileLines.findIndex((line) => line.trim() === endMarker);
+  let nextLines;
+  if (startIndex !== -1 && endIndex > startIndex) {
+    nextLines = [...fileLines.slice(0, startIndex), ...block, ...fileLines.slice(endIndex + 1)];
+  } else if (startIndex !== -1 || endIndex !== -1) {
+    console.error(`[agent-tools log] Unpaired markers for ${day} in ${outputFile}; skipped.`);
+    return;
+  } else {
+    nextLines = insertDatedBlock(fileLines, day, block);
+  }
+  const text = nextLines.join(eol).replace(/(\r?\n)*$/, eol);
+  await fs.mkdir(path.dirname(outputFile), { recursive: true });
+  await writeFileAtomic(outputFile, text);
+}
+function insertDatedBlock(fileLines, day, block) {
+  const dateLineRe = /^\+ (\d{4}-\d{2}-\d{2})\s*$/;
+  const dates = [];
+  for (let i = 0; i < fileLines.length; i += 1) {
+    const match = fileLines[i].match(dateLineRe);
+    if (match) dates.push({ index: i, date: match[1] });
+  }
+  const existing = dates.find((entry) => entry.date === day);
+  if (existing) {
+    const boundaryRe = /^(\+ \d{4}-\d{2}-\d{2}\s*$|#{1,6}\s)/;
+    let insertAt2 = fileLines.length;
+    for (let i = existing.index + 1; i < fileLines.length; i += 1) {
+      if (boundaryRe.test(fileLines[i])) {
+        insertAt2 = i;
+        break;
+      }
+    }
+    while (insertAt2 - 1 > existing.index && fileLines[insertAt2 - 1].trim() === "") insertAt2 -= 1;
+    const trailing = fileLines.slice(insertAt2);
+    const inserted = [...block];
+    if (trailing.length > 0 && trailing[0].trim() !== "") inserted.push("");
+    return [...fileLines.slice(0, insertAt2), ...inserted, ...trailing];
+  }
+  const ascending = dates.length < 2 || dates[0].date <= dates[dates.length - 1].date;
+  let insertAt = fileLines.length;
+  for (const entry of dates) {
+    if (ascending ? entry.date > day : entry.date < day) {
+      insertAt = entry.index;
+      break;
+    }
+  }
+  const dated = [`+ ${day}`, ...block];
+  const before = fileLines.slice(0, insertAt);
+  const after = fileLines.slice(insertAt);
+  if (before.length > 0 && before[before.length - 1].trim() !== "") before.push("");
+  if (after.length > 0 && after[0].trim() !== "") dated.push("");
+  return [...before, ...dated, ...after];
+}
+var STRINGS = {
+  zh: {
+    title: (date) => `# AI \u65E5\u62A5 - ${date}`,
+    updated: (time) => `\u66F4\u65B0\u65F6\u95F4: ${time}`,
+    overview: "## \u4ECA\u65E5\u6982\u89C8",
+    prompts: (n) => `- \u8BF7\u6C42\u6B21\u6570: ${n}`,
+    turns: (n) => `- \u6709\u6548\u8BB0\u5F55\u6570: ${n}`,
+    changedFiles: (n) => `- \u53D8\u66F4\u6587\u4EF6\u6570: ${n}`,
+    fileOps: (n) => `- \u4EE3\u7801\u64CD\u4F5C\u6B21\u6570: ${n}`,
+    lineChanges: (added, deleted) => `- \u603B\u884C\u53D8\u66F4: +${added}/-${deleted}`,
+    sessions: "## \u4F1A\u8BDD\u8BB0\u5F55",
+    none: "- \u65E0",
+    request: "Request",
+    outcome: "Outcome",
+    changes: "Changes",
+    fileLine: (file) => `- ${file.rel} | \u53D8\u66F4 ${file.diff} | \u64CD\u4F5C ${file.writes + file.edits} \u6B21`,
+    noPrompt: "\u672A\u8BB0\u5F55 prompt"
+  },
+  en: {
+    title: (date) => `# AI Log - ${date}`,
+    updated: (time) => `Updated: ${time}`,
+    overview: "## Overview",
+    prompts: (n) => `- Prompts: ${n}`,
+    turns: (n) => `- Recorded turns: ${n}`,
+    changedFiles: (n) => `- Changed files: ${n}`,
+    fileOps: (n) => `- File operations: ${n}`,
+    lineChanges: (added, deleted) => `- Line changes: +${added}/-${deleted}`,
+    sessions: "## Sessions",
+    none: "- none",
+    request: "Request",
+    outcome: "Outcome",
+    changes: "Changes",
+    fileLine: (file) => `- ${file.rel} | diff ${file.diff} | ${file.writes + file.edits} ops`,
+    noPrompt: "no prompt recorded"
+  }
+};
+async function renderDetailedReport(state, context) {
+  const t = STRINGS[context.language] || STRINGS.zh;
+  const scopeTurns = collectScopeTurns(state, context.scopeKey);
+  const turnEntries = await buildTurnEntries(state, context);
+  const changedFiles = new Set(
+    turnEntries.flatMap((entry) => entry.files.map((file) => file.rel))
+  );
+  const fileOps = scopeTurns.reduce(
+    (sum, turn) => sum + Object.values(turn.files || {}).reduce((s, f) => s + (f.writes || 0) + (f.edits || 0), 0),
+    0
+  );
+  const lineChanges = summarizeLineChanges(turnEntries);
+  const lines = [
+    t.title(state.date),
+    "",
+    t.updated(latestSessionTime(state) || "unknown"),
+    "",
+    t.overview,
+    "",
+    t.prompts(scopeTurns.length),
+    t.turns(turnEntries.length),
+    t.changedFiles(changedFiles.size),
+    t.fileOps(fileOps),
+    t.lineChanges(lineChanges.added, lineChanges.deleted),
+    "",
+    t.sessions,
+    ""
+  ];
+  if (turnEntries.length === 0) {
+    lines.push(t.none);
+  } else {
+    turnEntries.forEach((entry, index) => {
+      lines.push(`- Time: ${entry.first_time} -> ${entry.last_time}`);
+      if (entry.project) lines.push(`- Project: ${entry.project}`);
+      const requestText = entry.request_text || t.noPrompt;
+      const requestFence = fenceFor(requestText);
+      lines.push("", t.request, "", `${requestFence}text`, requestText, requestFence);
+      if (entry.result_summary) {
+        const outcomeFence = fenceFor(entry.result_summary);
+        lines.push("", t.outcome, "", `${outcomeFence}text`, entry.result_summary, outcomeFence);
+      }
+      lines.push("", t.changes, "");
+      if (entry.files.length === 0) {
+        lines.push(t.none);
+      } else {
+        for (const file of entry.files) lines.push(t.fileLine(file));
+      }
+      if (index < turnEntries.length - 1) lines.push("", "---", "");
+    });
+  }
+  lines.push("");
+  return `${lines.join("\n")}
+`;
+}
+function latestSessionTime(state) {
+  let latest = "";
+  for (const session of Object.values(state.sessions)) {
+    if (String(session.last_time || "") > latest) latest = String(session.last_time);
+  }
+  return latest;
+}
+function orderedSessions(state) {
+  return Object.values(state.sessions).sort(
+    (a, b) => String(a.first_time || "").localeCompare(String(b.first_time || ""))
+  );
+}
+function collectScopeTurns(state, scopeKey) {
+  const turns = [];
+  for (const session of orderedSessions(state)) {
+    for (const turn of session.turns || []) {
+      if (String(turn.scope || "") === scopeKey) turns.push(turn);
+    }
+  }
+  return turns;
+}
+async function buildTurnEntries(state, context) {
+  const entries = [];
+  for (const session of orderedSessions(state)) {
+    const sessionId = Object.keys(state.sessions).find((key) => state.sessions[key] === session);
+    for (const turn of session.turns || []) {
+      if (String(turn.scope || "") !== context.scopeKey) continue;
+      const files = await buildTurnFileEntries(sessionId, turn, context);
+      const requestText = String(turn.request_text || "");
+      const resultSummary = String(turn.result_summary || "");
+      if (files.length === 0 && (!hasSubstantiveTurn(requestText, resultSummary) || isTrivialTurn(requestText, resultSummary))) {
+        continue;
+      }
+      entries.push({
+        first_time: turn.first_time,
+        last_time: turn.last_time,
+        project: turn.project || "",
+        request_text: requestText,
+        result_summary: resultSummary,
+        files
+      });
+    }
+  }
+  entries.sort((a, b) => String(a.first_time || "").localeCompare(String(b.first_time || "")));
+  return entries;
+}
+async function buildTurnFileEntries(sessionId, turn, context) {
+  const entries = [];
+  const orderedFiles = Object.values(turn.files || {}).filter((item) => (item?.writes || 0) + (item?.edits || 0) > 0).sort((a, b) => b.writes + b.edits - (a.writes + a.edits));
+  for (const item of orderedFiles) {
+    entries.push({
+      rel: item.rel,
+      writes: item.writes || 0,
+      edits: item.edits || 0,
+      diff: await getTurnDiffLabel(sessionId, turn.turn_id, item, context)
+    });
+  }
+  return entries;
+}
+function fenceFor(text) {
+  const runs = String(text).match(/`{3,}/g);
+  const length = runs ? Math.max(...runs.map((run) => run.length)) + 1 : 3;
+  return "`".repeat(length);
+}
+async function getTurnDiffLabel(sessionId, turnId, turnFile, context) {
+  const baselineKind = turnFile.snapshot_kind || "unknown";
+  if (["binary", "large", "unknown"].includes(baselineKind)) return baselineKind;
+  const currentExists = await pathExists(turnFile.abs);
+  const emptyFilePath = await ensureEmptyFile(context.snapshotsRoot);
+  const leftPath = baselineKind === "text" ? getSnapshotPath(context.snapshotsRoot, buildSnapshotKey(sessionId, turnId), {
+    key: process.platform === "win32" ? turnFile.abs.toLowerCase() : turnFile.abs,
+    abs: turnFile.abs
+  }) : emptyFilePath;
+  const rightPath = currentExists ? turnFile.abs : emptyFilePath;
+  const result = spawnSync(
+    "git",
+    ["diff", "--no-index", "--numstat", "--no-ext-diff", "--no-textconv", "--", leftPath, rightPath],
+    { encoding: "utf8", windowsHide: true }
+  );
+  if (result.error || ![0, 1].includes(result.status ?? -1)) return "unknown";
+  const line = (result.stdout || "").split(/\r?\n/).map((item) => item.trim()).find(Boolean);
+  if (!line) return "+0/-0";
+  const [added, deleted] = line.split("	");
+  if (added === "-" || deleted === "-") return "binary";
+  return `+${Number(added || 0)}/-${Number(deleted || 0)}`;
+}
+function summarizeLineChanges(turnEntries) {
+  const total = { added: 0, deleted: 0 };
+  for (const entry of turnEntries) {
+    for (const file of entry.files || []) {
+      const match = String(file.diff || "").match(/^\+(\d+)\/-(\d+)$/);
+      if (!match) continue;
+      total.added += Number(match[1]);
+      total.deleted += Number(match[2]);
+    }
+  }
+  return total;
+}
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureEmptyFile(snapshotsRoot) {
+  const emptyFilePath = path.join(snapshotsRoot, ".empty");
+  try {
+    await fs.access(emptyFilePath);
+  } catch {
+    await fs.mkdir(snapshotsRoot, { recursive: true });
+    await fs.writeFile(emptyFilePath, "", "utf8");
+  }
+  return emptyFilePath;
+}
+function hasSubstantiveTurn(requestText, resultSummary) {
+  const request = String(requestText || "").trim();
+  const outcome = String(resultSummary || "").trim();
+  if (outcome.length >= MIN_RESULT_SUMMARY_LENGTH) return true;
+  if (request.length >= 32) return true;
+  if (/\n/.test(request) && request.length >= 16) return true;
+  return false;
+}
+function isTrivialTurn(requestText, resultSummary) {
+  const request = normalizeConversationText(requestText);
+  const outcome = normalizeConversationText(resultSummary);
+  if (!request && !outcome) return true;
+  const shortGreetingPattern = /^(hi|hello|hey|yo|test|testing|ping|pong|ok|okay|thanks|thank you|thx|你好|嗨|哈喽|在吗|测试|试试|好的|收到)$/;
+  if (shortGreetingPattern.test(request) && outcome.length <= 40) return true;
+  if (request.length <= 12 && outcome.length <= 40 && !/[一-龥a-z0-9].*[一-龥a-z0-9].*[一-龥a-z0-9]/i.test(request)) {
+    return true;
+  }
+  return false;
+}
+function normalizeConversationText(text) {
+  return String(text || "").toLowerCase().replace(/\r\n/g, "\n").replace(/[`#>*_-]+/g, " ").replace(/[.!?,，。！？]/g, " ").replace(/\s+/g, " ").trim();
+}
+function classifyCommand(command) {
+  const value = (command || "").toLowerCase();
+  if (!value.trim()) return "other";
+  if (/(^|\s)(pnpm|npm|yarn|bun|pytest|vitest|jest)\b/.test(value) || /\btest\b/.test(value)) return "test";
+  if (/\blint\b/.test(value)) return "lint";
+  if (/\btypecheck\b|\btsc\b/.test(value)) return "typecheck";
+  if (/\bbuild\b/.test(value)) return "build";
+  if (/\bformat\b|\bprettier\b|\bbiome\b/.test(value)) return "format";
+  if (/\bgit\b/.test(value)) return "git";
+  return "other";
+}
+function getEventName(input) {
+  return firstNonEmpty(input?.hook_event_name, input?.event_name, input?.event, input?.type);
+}
+function getSessionId(input) {
+  return String(firstNonEmpty(input?.session_id, input?.sessionId, input?.conversation_id) || "unknown");
+}
+function getPromptText(input) {
+  return firstNonEmpty(input?.prompt, input?.user_prompt, input?.message, input?.text);
+}
+function getOutcomeText(input) {
+  return firstNonEmpty(
+    input?.last_assistant_message,
+    input?.assistant_message,
+    input?.response,
+    input?.output,
+    input?.result
+  );
+}
+function getToolName(input) {
+  return firstNonEmpty(input?.tool_name, input?.toolName, input?.tool?.name, input?.name);
+}
+function getToolInput(input) {
+  return firstPlainObject(input?.tool_input, input?.toolInput, input?.input, input?.arguments);
+}
+function getToolFilePath(input) {
+  const toolInput = getToolInput(input);
+  return firstNonEmpty(toolInput.file_path, toolInput.filePath, toolInput.path, toolInput.target_file);
+}
+function getShellCommand(input) {
+  const toolInput = getToolInput(input);
+  return firstNonEmpty(toolInput.command, toolInput.cmd, toolInput.script);
+}
+async function writeFileAtomic(file, text) {
+  const temp = `${file}.${process.pid}.tmp`;
+  await fs.writeFile(temp, text, "utf8");
+  await fs.rename(temp, file);
+}
+function excerptMultiline(text, limit) {
+  const value = String(text || "").replace(/\r\n/g, "\n").trim();
+  if (value.length <= limit) return value;
+  return `${value.slice(0, Math.max(0, limit - 3))}...`;
+}
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function firstNonEmpty(...values) {
+  return values.find((value) => typeof value === "string" && value.trim()) || "";
+}
+function firstPlainObject(...values) {
+  return values.find((value) => isPlainObject(value)) || {};
+}
+function normalizePath(value) {
+  return String(value || "").replace(/\\/g, "/");
+}
+function expandHome(value) {
+  if (value === "~") return os.homedir();
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return path.join(os.homedir(), value.slice(2));
+  }
+  return value;
+}
+function stripBom(text) {
+  return String(text || "").replace(/^\uFEFF/, "");
+}
+function simpleHash(input) {
+  let hash = 0;
+  const text = String(input || "");
+  for (let index = 0; index < text.length; index += 1) {
+    hash = hash * 31 + text.charCodeAt(index) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+function formatLocalDate(date) {
+  const year = date.getFullYear();
+  const month = `${date.getMonth() + 1}`.padStart(2, "0");
+  const day = `${date.getDate()}`.padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function formatLocalDateTime(date) {
+  const hours = `${date.getHours()}`.padStart(2, "0");
+  const minutes = `${date.getMinutes()}`.padStart(2, "0");
+  const seconds = `${date.getSeconds()}`.padStart(2, "0");
+  return `${formatLocalDate(date)} ${hours}:${minutes}:${seconds}`;
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+main().catch((error) => {
+  console.error(`[agent-tools log] ${error.stack || error.message}`);
+  process.exit(0);
+});