blun-king-cli 9.1.203 → 9.1.205

package/bin/error-memory-performance-policy.cjs

@@ -1,6 +1,69 @@
 'use strict';
 
 const ERROR_MEMORY_MAX_CHARS = 2_800;
+const ERROR_MEMORY_MAX_PATTERNS = 6;
+const CORE_PATTERN_NUMBERS = new Set([4, 9, 10, 11]);
+const STOP_WORDS = new Set([
+  'aber', 'alle', 'alles', 'auch', 'belegt', 'beweis', 'echt', 'echte', 'echten',
+  'echter', 'eine', 'einem', 'einen', 'einer', 'das', 'den', 'fuer', 'gegen',
+  'haben', 'hier', 'immer',
+  'jetzt', 'kann', 'machen', 'mehr', 'nicht', 'noch', 'oder', 'pruefe', 'pruefen',
+  'pruefung', 'sein', 'sind', 'soll', 'und', 'vollstaendig', 'vollstaendige',
+  'wenn', 'werden', 'with', 'that',
+  'this', 'from', 'have', 'into', 'your', 'you', 'the', 'and', 'for', 'are',
+]);
+
+function normalizedTerms(value) {
+  return [...new Set(String(value || '')
+    .normalize('NFKD')
+    .replace(/\p{M}/gu, '')
+    .toLowerCase()
+    .match(/[\p{L}\p{N}_-]{3,}/gu) || [])]
+    .filter((term) => !STOP_WORDS.has(term));
+}
+
+function fieldMatchesTerm(fieldTerms, term) {
+  return fieldTerms.some((fieldTerm) => (
+    fieldTerm === term
+    || (term.length >= 6 && fieldTerm.includes(term))
+    || (fieldTerm.length >= 6 && term.includes(fieldTerm))
+  ));
+}
+
+function selectRelevantErrorMemoryPatterns(patterns, query, options = {}) {
+  const maxPatterns = Math.max(1, Number(options.maxPatterns) || ERROR_MEMORY_MAX_PATTERNS);
+  const source = Array.isArray(patterns) ? patterns.filter(Boolean) : [];
+  if (source.length <= maxPatterns) return source;
+
+  const queryTerms = normalizedTerms(query);
+  const ranked = source.map((pattern, index) => {
+    const title = normalizedTerms(pattern.title);
+    const rule = normalizedTerms(pattern.rule);
+    const check = normalizedTerms(pattern.check);
+    let score = 0;
+    for (const term of queryTerms) {
+      if (fieldMatchesTerm(title, term)) score += 4;
+      if (fieldMatchesTerm(rule, term)) score += 2;
+      if (fieldMatchesTerm(check, term)) score += 1;
+    }
+    return { index, pattern, score };
+  });
+  const selectedIndexes = new Set(ranked
+    .filter(({ pattern }) => CORE_PATTERN_NUMBERS.has(Number(pattern.number)))
+    .map(({ index }) => index));
+  ranked
+    .filter(({ index, score }) => !selectedIndexes.has(index) && score > 0)
+    .sort((left, right) => right.score - left.score || left.index - right.index)
+    .slice(0, Math.max(0, maxPatterns - selectedIndexes.size))
+    .forEach(({ index }) => selectedIndexes.add(index));
+
+  if (selectedIndexes.size === 0) {
+    source.slice(-Math.min(2, maxPatterns)).forEach((pattern) => {
+      selectedIndexes.add(source.indexOf(pattern));
+    });
+  }
+  return source.filter((pattern, index) => selectedIndexes.has(index)).slice(0, maxPatterns);
+}
 
 function buildCompactErrorMemoryReminder(patterns) {
   const lines = [
@@ -42,7 +105,9 @@ function compactLegacyErrorMemoryReminder(text) {
 }
 
 module.exports = {
+  ERROR_MEMORY_MAX_PATTERNS,
   ERROR_MEMORY_MAX_CHARS,
   buildCompactErrorMemoryReminder,
   compactLegacyErrorMemoryReminder,
+  selectRelevantErrorMemoryPatterns,
 };

package/bin/repeated-assistant-response-policy.cjs

@@ -8,6 +8,7 @@ const REPEATED_RESPONSE_PLACEHOLDER = '[Historical repeated assistant response o
 const INTRA_MESSAGE_MIN_REPEATS = 3;
 const INTRA_MESSAGE_MIN_BLOCK_CHARS = 40;
 const INTRA_MESSAGE_MIN_SAVED_CHARS = 1_000;
+const INTRA_MESSAGE_SIMILARITY_THRESHOLD = 0.88;
 const INTRA_MESSAGE_REPEAT_PLACEHOLDER = '[Exact repeated assistant paragraphs omitted from model projection; raw history preserved.]';
 
 function isUserPrompt(message) {
@@ -60,6 +61,17 @@ function responseSimilarity(left, right) {
   return (2 * intersection) / (leftBigrams.size + rightBigrams.size);
 }
 
+function fencedBlockIndexes(blocks) {
+  const protectedIndexes = new Set();
+  let insideFence = false;
+  for (let index = 0; index < blocks.length; index += 1) {
+    const fenceCount = blocks[index].match(/(?:^|\n)\s*(?:```|~~~)/gu)?.length ?? 0;
+    if (insideFence || fenceCount > 0) protectedIndexes.add(index);
+    if (fenceCount % 2 === 1) insideFence = !insideFence;
+  }
+  return protectedIndexes;
+}
+
 function hasUserPromptBetween(history, leftIndex, rightIndex) {
   for (let index = leftIndex + 1; index < rightIndex; index += 1) {
     if (isUserPrompt(history[index])) return true;
@@ -120,27 +132,31 @@ function compactRepeatedAssistantParagraphs(message) {
   )) return null;
 
   const text = textParts[0].text;
-  if (/```|~~~/u.test(text)) return null;
   const blocks = text.split(/\n\s*\n/u).map((block) => block.trim()).filter(Boolean);
   if (blocks.length < INTRA_MESSAGE_MIN_REPEATS + 1) return null;
+  const protectedIndexes = fencedBlockIndexes(blocks);
+
+  const clusters = [];
+  for (let index = 0; index < blocks.length; index += 1) {
+    const block = blocks[index];
+    if (protectedIndexes.has(index) || block.length < INTRA_MESSAGE_MIN_BLOCK_CHARS) continue;
+    const cluster = clusters.find((candidate) => (
+      candidate.representative === block
+      || responseSimilarity(candidate.representative, block) >= INTRA_MESSAGE_SIMILARITY_THRESHOLD
+    ));
+    if (cluster) cluster.indexes.push(index);
+    else clusters.push({ indexes: [index], representative: block });
+  }
+  const repeatedIndexes = new Set(clusters
+    .filter((cluster) => cluster.indexes.length >= INTRA_MESSAGE_MIN_REPEATS)
+    .flatMap((cluster) => cluster.indexes.slice(1)));
+  if (repeatedIndexes.size === 0) return null;
 
-  const counts = new Map();
-  for (const block of blocks) counts.set(block, (counts.get(block) ?? 0) + 1);
-  const repeated = new Set([...counts]
-    .filter(([block, count]) => (
-      block.length >= INTRA_MESSAGE_MIN_BLOCK_CHARS
-      && count >= INTRA_MESSAGE_MIN_REPEATS
-    ))
-    .map(([block]) => block));
-  if (repeated.size === 0) return null;
-
-  const seen = new Set();
   const projectedBlocks = [];
   let markerAdded = false;
-  for (const block of blocks) {
-    if (!repeated.has(block) || !seen.has(block)) {
-      projectedBlocks.push(block);
-      if (repeated.has(block)) seen.add(block);
+  for (let index = 0; index < blocks.length; index += 1) {
+    if (!repeatedIndexes.has(index)) {
+      projectedBlocks.push(blocks[index]);
       continue;
     }
     if (!markerAdded) {
@@ -184,6 +200,7 @@ module.exports = {
   INTRA_MESSAGE_MIN_BLOCK_CHARS,
   INTRA_MESSAGE_MIN_REPEATS,
   INTRA_MESSAGE_MIN_SAVED_CHARS,
+  INTRA_MESSAGE_SIMILARITY_THRESHOLD,
   INTRA_MESSAGE_REPEAT_PLACEHOLDER,
   MAX_RECENT_ASSISTANT_RESPONSES,
   MIN_RESPONSE_CHARS,

package/blun.mjs

@@ -79260,6 +79260,11 @@ var init_error_memory$1 = __esmMin((() => {
 		getInjection() {
 			const patterns = this.agent.errorMemory?.getActivePatterns();
 			if (!patterns || patterns.length === 0) return void 0;
+			try {
+				const { buildCompactErrorMemoryReminder, selectRelevantErrorMemoryPatterns } = createRequire(import.meta.url)("./bin/error-memory-performance-policy.cjs");
+				const { recentUserText } = createRequire(import.meta.url)("./bin/mistake-relevance-policy.cjs");
+				return buildCompactErrorMemoryReminder(selectRelevantErrorMemoryPatterns(patterns, recentUserText(this.agent.context.history)));
+			} catch {}
 			return buildErrorMemoryReminder(patterns);
 		}
 	};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.203",
+  "version": "9.1.205",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {