@riconext/hermes-repo 1.2.1 → 1.2.3

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 1.2.3
+
+### Patch Changes
+
+- 17d33f3: 增加 flush 调用 LLM 时的详细 debug 日志，便于检查请求输入、原始响应和标准化后的知识文件结果。
+
+## 1.2.2
+
+### Patch Changes
+
+- a8aff7f: 记录 flush 执行过程到 debug 日志，并在写入 MEMORY.md 前校验知识文件链接是否真实存在。
+
 ## 1.2.1
 
 ### Patch Changes

package/dist/cli.js

@@ -62,6 +62,16 @@ function debugLog(enabled, phase, message) {
   console.error(line);
   writeToLogFile(line);
 }
+function debugLogBlock(enabled, phase, label, content) {
+  if (!enabled) {
+    return;
+  }
+  debugLog(true, phase, `${label} BEGIN`);
+  for (const line of content.split(/\r?\n/)) {
+    debugLog(true, phase, `| ${line}`);
+  }
+  debugLog(true, phase, `${label} END`);
+}
 function debugFromContext(ctx, phase, message) {
   debugLog(ctx?.config.debug === true, phase, message);
 }
@@ -1423,7 +1433,7 @@ function buildLlmConsolidateInput(repoRoot, sessions) {
     currentMemoryMd
   };
 }
-async function callLlmConsolidate(input2, llmConfig) {
+async function callLlmConsolidate(input2, llmConfig, debug = false) {
   if (!llmConfig.enabled) {
     throw new Error(
       "LLM \u672A\u542F\u7528\uFF1A\u8BF7\u5728 config.json \u4E2D\u8BBE\u7F6E llm.enabled = true"
@@ -1436,6 +1446,23 @@ async function callLlmConsolidate(input2, llmConfig) {
   }
   const url = `${llmConfig.baseUrl.replace(/\/$/, "")}/chat/completions`;
   const userContent = formatUserMessage(input2);
+  debugLog(
+    debug,
+    "llm",
+    `request: provider=${llmConfig.provider}, model=${llmConfig.model}, baseUrl=${llmConfig.baseUrl}, pendingSessions=${input2.pendingSessions.length}, existingKnowledge=${input2.existingKnowledge.length}, currentMemoryChars=${input2.currentMemoryMd?.length ?? 0}`
+  );
+  debugLogBlock(debug, "llm", "system prompt", CONSOLIDATE_SYSTEM_PROMPT);
+  debugLogBlock(debug, "llm", "user input", userContent);
+  const requestBody = {
+    model: llmConfig.model,
+    response_format: { type: "json_object" },
+    messages: [
+      { role: "system", content: CONSOLIDATE_SYSTEM_PROMPT },
+      { role: "user", content: userContent }
+    ],
+    temperature: 0.2
+  };
+  debugLogBlock(debug, "llm", "request body", JSON.stringify(requestBody, null, 2));
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), 12e4);
   try {
@@ -1445,35 +1472,58 @@ async function callLlmConsolidate(input2, llmConfig) {
         "Content-Type": "application/json",
         Authorization: `Bearer ${llmConfig.apiKey}`
       },
-      body: JSON.stringify({
-        model: llmConfig.model,
-        response_format: { type: "json_object" },
-        messages: [
-          { role: "system", content: CONSOLIDATE_SYSTEM_PROMPT },
-          { role: "user", content: userContent }
-        ],
-        temperature: 0.2
-      }),
+      body: JSON.stringify(requestBody),
       signal: controller.signal
     });
+    debugLog(debug, "llm", `response status: ${res.status} ${res.statusText}`);
     if (!res.ok) {
       const errBody = await res.text().catch(() => "");
+      debugLogBlock(debug, "llm", "error response body", errBody);
       throw new Error(
         `LLM API \u9519\u8BEF (${res.status}): ${errBody.slice(0, 300)}`
       );
     }
     const data = await res.json();
+    debugLogBlock(debug, "llm", "response json", JSON.stringify(data, null, 2));
     const rawContent = data.choices?.[0]?.message?.content;
     if (!rawContent) {
       throw new Error("LLM \u8FD4\u56DE\u5185\u5BB9\u4E3A\u7A7A");
     }
+    debugLogBlock(debug, "llm", "raw message content", rawContent);
     let parsed;
     try {
       parsed = JSON.parse(rawContent);
     } catch {
       throw new Error("LLM \u8FD4\u56DE\u5185\u5BB9\u4E0D\u662F\u5408\u6CD5 JSON");
     }
-    return validateAndNormalizeLlmResult(parsed);
+    debugLogBlock(debug, "llm", "parsed content", JSON.stringify(parsed, null, 2));
+    const normalized = validateAndNormalizeLlmResult(parsed);
+    debugLog(
+      debug,
+      "llm",
+      `normalized: knowledgeFiles=${normalized.knowledgeFiles.length}, memoryChars=${normalized.memoryMd.length}, skippedSessions=${normalized.skippedSessions.length}`
+    );
+    debugLogBlock(
+      debug,
+      "llm",
+      "normalized knowledgeFiles",
+      JSON.stringify(normalized.knowledgeFiles, null, 2)
+    );
+    debugLogBlock(debug, "llm", "normalized memoryMd", normalized.memoryMd);
+    debugLogBlock(
+      debug,
+      "llm",
+      "normalized skippedSessions",
+      JSON.stringify(normalized.skippedSessions, null, 2)
+    );
+    return normalized;
+  } catch (err) {
+    debugLog(
+      debug,
+      "llm",
+      `error: ${err instanceof Error ? err.message : String(err)}`
+    );
+    throw err;
   } finally {
     clearTimeout(timeout);
   }
@@ -1537,6 +1587,13 @@ function isSkippedEntry(raw) {
 // src/consolidate/writeKnowledge.ts
 import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "fs";
 import { dirname as dirname4 } from "path";
+var KNOWLEDGE_LINK_PREFIXES = [
+  "rules/",
+  "domains/",
+  "workflows/",
+  "decisions/",
+  "incidents/"
+];
 function writeKnowledgeFiles(repoRoot, files) {
   const result = {
     created: [],
@@ -1580,6 +1637,38 @@ function writeMemoryMd(repoRoot, memoryMd) {
   writeFileSync5(memoryPathAbs, `${memoryMd}
 `, "utf8");
 }
+function assertMemoryKnowledgeLinksExist(repoRoot, memoryMd) {
+  const missing = findMissingKnowledgeLinks(repoRoot, memoryMd);
+  if (missing.length > 0) {
+    throw new Error(
+      `MEMORY.md \u5F15\u7528\u4E86\u4E0D\u5B58\u5728\u7684\u77E5\u8BC6\u6587\u4EF6: ${missing.join(", ")}`
+    );
+  }
+}
+function findMissingKnowledgeLinks(repoRoot, memoryMd) {
+  const links = extractKnowledgeLinks(memoryMd);
+  return links.filter((link) => !existsSync7(memoryPath(repoRoot, link)));
+}
+function extractKnowledgeLinks(memoryMd) {
+  const links = /* @__PURE__ */ new Set();
+  const markdownLink = /\[[^\]]+\]\(([^)]+)\)/g;
+  let match;
+  while ((match = markdownLink.exec(memoryMd)) !== null) {
+    const normalized = normalizeKnowledgeLink(match[1]);
+    if (normalized) {
+      links.add(normalized);
+    }
+  }
+  return [...links];
+}
+function normalizeKnowledgeLink(rawLink) {
+  const withoutAnchor = rawLink.split("#")[0].trim();
+  const withoutDotSlash = withoutAnchor.startsWith("./") ? withoutAnchor.slice(2) : withoutAnchor;
+  if (withoutDotSlash.includes("://") || withoutDotSlash.startsWith("/") || withoutDotSlash.includes("..") || !withoutDotSlash.endsWith(".md")) {
+    return null;
+  }
+  return KNOWLEDGE_LINK_PREFIXES.some((prefix) => withoutDotSlash.startsWith(prefix)) ? withoutDotSlash : null;
+}
 function serializeKnowledgeFile(frontmatter, body) {
   const lines = ["---"];
   const fieldOrder = ["title", "domain", "type", "status", "confidence", "lastReviewed"];
@@ -1666,10 +1755,17 @@ function archiveDoneSessions(repoRoot, sessions, autoArchiveDays = 30) {
 // src/consolidate/runConsolidate.ts
 async function runConsolidate(opts) {
   const { repoRoot, config, force, dryRun, debug } = opts;
+  debugLog(
+    debug === true,
+    "consolidate",
+    `start: force=${force === true}, dryRun=${dryRun === true}`
+  );
   writeConsolidateLock(repoRoot);
+  debugLog(debug === true, "consolidate", "lock acquired");
   try {
     const llmConfig = config.llm;
     if (!llmConfig.enabled) {
+      debugLog(debug === true, "consolidate", "skip: llm not enabled");
       return {
         ran: false,
         reason: "llm-not-enabled",
@@ -1688,6 +1784,7 @@ async function runConsolidate(opts) {
       `\u626B\u63CF\u5230 ${allSessions.length} \u4E2A session\uFF0C\u5176\u4E2D ${pendingSessions.length} \u4E2A\u5F85\u5904\u7406`
     );
     if (pendingSessions.length === 0 && !force) {
+      debugLog(debug === true, "consolidate", "skip: no pending sessions");
       return {
         ran: false,
         reason: "no-pending-sessions",
@@ -1699,6 +1796,11 @@ async function runConsolidate(opts) {
       };
     }
     if (dryRun) {
+      debugLog(
+        debug === true,
+        "consolidate",
+        `dry-run: would process ${pendingSessions.length} session(s)`
+      );
       return {
         ran: true,
         reason: "dry-run",
@@ -1710,10 +1812,14 @@ async function runConsolidate(opts) {
       };
     }
     const llmInput = buildLlmConsolidateInput(repoRoot, pendingSessions);
-    debugLog(debug === true, "consolidate", `LLM \u8F93\u5165: ${llmInput.pendingSessions.length} sessions, ${llmInput.existingKnowledge.length} existing knowledge`);
+    debugLog(
+      debug === true,
+      "consolidate",
+      `LLM \u8F93\u5165: ${llmInput.pendingSessions.length} sessions, ${llmInput.existingKnowledge.length} existing knowledge`
+    );
     let llmResult;
     try {
-      llmResult = await callLlmConsolidate(llmInput, llmConfig);
+      llmResult = await callLlmConsolidate(llmInput, llmConfig, debug === true);
     } catch (err) {
       console.error(`[consolidate] LLM \u8C03\u7528\u5931\u8D25: ${err.message}`);
       throw err;
@@ -1723,8 +1829,33 @@ async function runConsolidate(opts) {
       "consolidate",
       `LLM \u8FD4\u56DE: ${llmResult.knowledgeFiles.length} knowledge files, ${llmResult.skippedSessions.length} skipped`
     );
+    debugLog(debug === true, "consolidate", "writing knowledge files");
     const writeResult = writeKnowledgeFiles(repoRoot, llmResult.knowledgeFiles);
+    if (writeResult.failed.length > 0) {
+      debugLog(
+        debug === true,
+        "consolidate",
+        `write failed: ${writeResult.failed.join(", ")}`
+      );
+      throw new Error(
+        `\u77E5\u8BC6\u6587\u4EF6\u5199\u5165\u5931\u8D25: ${writeResult.failed.join(", ")}`
+      );
+    }
+    debugLog(
+      debug === true,
+      "consolidate",
+      `knowledge files written: created=${writeResult.created.length}, updated=${writeResult.updated.length}`
+    );
+    debugLog(debug === true, "consolidate", "validating MEMORY.md links");
+    assertMemoryKnowledgeLinksExist(repoRoot, llmResult.memoryMd);
+    debugLog(debug === true, "consolidate", "MEMORY.md links ok");
+    debugLog(debug === true, "consolidate", "writing MEMORY.md");
     writeMemoryMd(repoRoot, llmResult.memoryMd);
+    debugLog(
+      debug === true,
+      "consolidate",
+      `marking sessions done: ${pendingSessions.length} processed, ${llmResult.skippedSessions.length} skipped`
+    );
     const processedSessionIds = /* @__PURE__ */ new Set();
     for (const s of pendingSessions) {
       markSessionConsolidated(repoRoot, s.sessionId);
@@ -1736,6 +1867,7 @@ async function runConsolidate(opts) {
     }
     const prevState = readConsolidateState(repoRoot);
     const newDomains = extractDomainsFromResults(llmResult.knowledgeFiles);
+    debugLog(debug === true, "consolidate", "updating consolidate state");
     writeConsolidateState(repoRoot, {
       version: 2,
       lastConsolidatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1759,6 +1891,12 @@ async function runConsolidate(opts) {
       allSessions,
       config.consolidate.autoArchiveDays
     );
+    debugLog(debug === true, "consolidate", `archived sessions: ${archived}`);
+    debugLog(
+      debug === true,
+      "consolidate",
+      `done: sessions=${pendingSessions.length}, created=${writeResult.created.length}, updated=${writeResult.updated.length}, skipped=${llmResult.skippedSessions.length}, archived=${archived}`
+    );
     return {
       ran: true,
       sessionsProcessed: pendingSessions.length,
@@ -1769,6 +1907,7 @@ async function runConsolidate(opts) {
     };
   } finally {
     releaseConsolidateLock(repoRoot);
+    debugLog(debug === true, "consolidate", "lock released");
   }
 }
 function extractDomainsFromResults(files) {
@@ -2421,12 +2560,25 @@ function runCaptureCommand(opts) {
 
 // src/commands/flush.ts
 async function runFlushCommandCli(opts) {
+  const ctx = loadRepoContext(opts.cwd);
+  const debug = ctx?.config.debug === true;
+  configureDebugLogging(ctx?.repoRoot ?? null, debug);
+  debugLog(
+    debug,
+    "flush",
+    `start: force=${opts.force === true}, dryRun=${opts.dryRun === true}`
+  );
   try {
     const result = await runFlushCommand({
       cwd: opts.cwd,
       force: opts.force,
       dryRun: opts.dryRun
     });
+    debugLog(
+      debug,
+      "flush",
+      `result: ran=${result.ran}, reason=${result.reason ?? "ok"}, sessions=${result.sessionsProcessed}, created=${result.knowledgeCreated}, updated=${result.knowledgeUpdated}, skipped=${result.skippedCount}, archived=${result.archived}`
+    );
     if (result.ran) {
       if (result.reason === "dry-run") {
         console.error(
@@ -2466,6 +2618,11 @@ async function runFlushCommandCli(opts) {
     }
     hookExit(0, opts.strict);
   } catch (err) {
+    debugLog(
+      debug,
+      "flush",
+      `error: ${err instanceof Error ? err.message : String(err)}`
+    );
     console.error(
       `hermes-repo flush: ${err instanceof Error ? err.message : String(err)}`
     );