@kenkaiiii/gg-boss 4.8.0 → 4.8.2

package/dist/{chunk-JZC6MVWQ.js → chunk-ROHVABKQ.js}

@@ -74730,7 +74730,9 @@ var SettingsSchema = external_exports.object({
   ]).default("auto"),
   showTokenUsage: external_exports.boolean().default(true),
   idealReviewEnabled: external_exports.boolean().default(true),
-  enabledTools: external_exports.array(external_exports.string()).optional()
+  enabledTools: external_exports.array(external_exports.string()).optional(),
+  /** Delete session transcripts older than this many days at startup. 0 disables pruning. */
+  sessionRetentionDays: external_exports.number().int().min(0).default(30)
 });
 var DEFAULT_SETTINGS = {
   autoCompact: true,
@@ -74740,7 +74742,8 @@ var DEFAULT_SETTINGS = {
   thinkingEnabled: false,
   theme: "auto",
   showTokenUsage: true,
-  idealReviewEnabled: true
+  idealReviewEnabled: true,
+  sessionRetentionDays: 30
 };
 var SettingsManager = class {
   settings = { ...DEFAULT_SETTINGS };
@@ -74792,9 +74795,29 @@ function encodeCwd(cwd2) {
 }
 var SessionManager = class _SessionManager {
   sessionsDir;
+  warnedPersistCodes = /* @__PURE__ */ new Set();
+  /** Called once per error code when session persistence fails (e.g. ENOSPC). */
+  onPersistError;
   constructor(sessionsDir) {
     this.sessionsDir = sessionsDir;
   }
+  /**
+   * Session persistence must never crash a live session. Disk-full (ENOSPC),
+   * permission, or quota errors during transcript writes are reported once
+   * per error code and otherwise swallowed — the in-memory session keeps going.
+   */
+  handlePersistError(error51, op) {
+    const err = error51;
+    const code = err?.code ?? "UNKNOWN";
+    if (this.warnedPersistCodes.has(code))
+      return;
+    this.warnedPersistCodes.add(code);
+    log("WARN", "session", `Session persistence failed (${op}); continuing without saving`, {
+      code,
+      message: err?.message ?? String(error51)
+    });
+    this.onPersistError?.(err);
+  }
   dirForCwd(cwd2) {
     return path27.join(this.sessionsDir, encodeCwd(cwd2));
   }
@@ -74923,10 +74946,76 @@ var SessionManager = class _SessionManager {
     const sessions = await this.list(cwd2);
     return sessions.find((session) => session.id === sessionId2)?.path ?? null;
   }
+  /**
+   * Delete session files older than `maxAgeDays` across ALL project dirs.
+   * Age is judged by file mtime, so a session that's still being appended to
+   * is never considered old. Best-effort: per-file errors are skipped so a
+   * locked or vanished file can't break startup. Empty project dirs left
+   * behind are removed. Returns what was freed for logging.
+   */
+  async pruneOldSessions(options) {
+    const result = { deletedFiles: 0, freedBytes: 0 };
+    if (options.maxAgeDays <= 0)
+      return result;
+    const cutoffMs = Date.now() - options.maxAgeDays * 864e5;
+    const keep = new Set((options.keepPaths ?? []).map((p) => path27.resolve(p)));
+    let cwdDirs;
+    try {
+      cwdDirs = await fs23.readdir(this.sessionsDir);
+    } catch {
+      return result;
+    }
+    for (const dirName of cwdDirs) {
+      const dir = path27.join(this.sessionsDir, dirName);
+      let files;
+      try {
+        const stat = await fs23.stat(dir);
+        if (!stat.isDirectory())
+          continue;
+        files = await fs23.readdir(dir);
+      } catch {
+        continue;
+      }
+      let remaining = files.length;
+      for (const file2 of files) {
+        if (!file2.endsWith(".jsonl"))
+          continue;
+        const filePath = path27.join(dir, file2);
+        if (keep.has(path27.resolve(filePath)))
+          continue;
+        try {
+          const stat = await fs23.stat(filePath);
+          if (stat.mtimeMs >= cutoffMs)
+            continue;
+          await fs23.unlink(filePath);
+          result.deletedFiles += 1;
+          result.freedBytes += stat.size;
+          remaining -= 1;
+        } catch {
+        }
+      }
+      if (remaining === 0) {
+        await fs23.rmdir(dir).catch(() => {
+        });
+      }
+    }
+    return result;
+  }
   async appendEntry(sessionPath, entry) {
-    await fs23.appendFile(sessionPath, JSON.stringify(entry) + "\n", "utf-8");
+    try {
+      await fs23.appendFile(sessionPath, JSON.stringify(entry) + "\n", "utf-8");
+    } catch (error51) {
+      this.handlePersistError(error51, "appendEntry");
+    }
   }
   async updateLeaf(sessionPath, leafId) {
+    try {
+      await this.updateLeafUnsafe(sessionPath, leafId);
+    } catch (error51) {
+      this.handlePersistError(error51, "updateLeaf");
+    }
+  }
+  async updateLeafUnsafe(sessionPath, leafId) {
     const fd2 = await fs23.open(sessionPath, "r+");
     try {
       const buf = Buffer.alloc(4096);
@@ -107605,12 +107694,40 @@ function renderMarkdownToAnsiLines({ text, theme, width, isPending = false, avai
     if (tableHeaders.length > 0 && tableRows.length > 0) {
       const styledHeaders = tableHeaders.map((header) => renderInlineMarkdownToAnsi(stripUnsafeCharacters(header), theme, theme.link));
       const styledRows = tableRows.map((row) => row.map((cell) => renderInlineMarkdownToAnsi(stripUnsafeCharacters(cell), theme, theme.text)));
-      addLines(renderAnsiTable({ headers: styledHeaders, rows: styledRows, terminalWidth: width, theme }));
+      const tableLines = renderAnsiTable({
+        headers: styledHeaders,
+        rows: styledRows,
+        terminalWidth: width,
+        theme
+      });
+      if (isPending && availableTerminalHeight !== void 0) {
+        const reservedLines = 2;
+        const maxTableLinesWhenPending = Math.max(0, availableTerminalHeight - reservedLines);
+        if (tableLines.length > maxTableLinesWhenPending) {
+          if (maxTableLinesWhenPending < 1) {
+            addLines([colorize3("... table is being written ...", theme.textMuted)]);
+          } else {
+            addLines(tableLines.slice(0, maxTableLinesWhenPending));
+            addLines([colorize3("... generating more ...", theme.textMuted)]);
+          }
+          inTable = false;
+          tableRows = [];
+          tableHeaders = [];
+          return;
+        }
+      }
+      addLines(tableLines);
     }
     inTable = false;
     tableRows = [];
     tableHeaders = [];
   };
+  let pendingTableTailStart = lines.length;
+  if (isPending) {
+    while (pendingTableTailStart > 0 && /^\s*\|/.test(lines[pendingTableTailStart - 1] ?? "") && lines.length - pendingTableTailStart < 2) {
+      pendingTableTailStart -= 1;
+    }
+  }
   lines.forEach((line, index) => {
     if (inCodeBlock) {
       const fenceMatch = line.match(codeFenceRegex);
@@ -107641,7 +107758,7 @@ function renderMarkdownToAnsiLines({ text, theme, width, isPending = false, avai
         inTable = true;
         tableHeaders = tableRowMatch[1]?.split("|").map((cell) => cell.trim()) ?? [];
         tableRows = [];
-      } else {
+      } else if (index < pendingTableTailStart) {
         addInlineLine(line);
       }
     } else if (inTable && tableSeparatorMatch) {
@@ -107653,6 +107770,9 @@ function renderMarkdownToAnsiLines({ text, theme, width, isPending = false, avai
         cells.length = tableHeaders.length;
       tableRows.push(cells);
     } else if (inTable && !tableRowMatch) {
+      if (index >= pendingTableTailStart) {
+        return;
+      }
       flushTable();
       if (line.trim().length > 0)
         addInlineLine(line);
@@ -107678,7 +107798,7 @@ function renderMarkdownToAnsiLines({ text, theme, width, isPending = false, avai
         output.push(EMPTY_RENDER_LINE);
         lastLineEmpty = true;
       }
-    } else {
+    } else if (index < pendingTableTailStart) {
       addInlineLine(line);
     }
   });
@@ -114607,4 +114727,4 @@ react/cjs/react-jsx-runtime.development.js:
    * LICENSE file in the root directory of this source tree.
    *)
 */
-//# sourceMappingURL=chunk-JZC6MVWQ.js.map
+//# sourceMappingURL=chunk-ROHVABKQ.js.map