blun-king-cli 9.1.564 → 9.1.566

package/bin/thinking-activity-status-policy.cjs

@@ -0,0 +1,132 @@
+'use strict';
+
+const ACTIVITY_CHANGE_INTERVAL_MS = 3_000;
+
+const THINKING_ACTIVITY_WORDS = Object.freeze({
+  Thinking: Object.freeze([
+    'Thinkering', 'Reasoning', 'Pondering', 'Analyzing', 'Exploring',
+    'Connecting', 'Unraveling', 'Imagining', 'Envisioning', 'Strategizing',
+    'Deciphering', 'Framing', 'Ideating', 'Synthesizing', 'Reflecting',
+  ]),
+  Planning: Object.freeze([
+    'Architecting', 'Blueprinting', 'Structuring', 'Orchestrating', 'Sequencing',
+    'Scoping', 'Prioritizing', 'Coordinating', 'Decomposing', 'Aligning',
+    'Roadmapping', 'Modeling', 'Designing', 'Drafting', 'Preparing',
+  ]),
+  Researching: Object.freeze([
+    'Searching', 'Browsing', 'Discovering', 'Investigating', 'Examining',
+    'Inspecting', 'Tracing', 'Comparing', 'Verifying', 'Cross-checking',
+    'Fact-finding', 'Source-hunting', 'Deep-diving', 'Contextualizing', 'Evidence-gathering',
+  ]),
+  Building: Object.freeze([
+    'Building', 'Crafting', 'Coding', 'Engineering', 'Assembling',
+    'Integrating', 'Implementing', 'Wiring', 'Configuring', 'Compiling',
+    'Rendering', 'Generating', 'Prototyping', 'Shaping', 'Forging',
+  ]),
+  Solving: Object.freeze([
+    'Debugging', 'Diagnosing', 'Troubleshooting', 'Untangling', 'Repairing',
+    'Patching', 'Resolving', 'Reworking', 'Refining', 'Optimizing',
+    'Simplifying', 'Stabilizing', 'Recovering', 'Calibrating', 'Tuning',
+  ]),
+  Validating: Object.freeze([
+    'Testing', 'Validating', 'Reviewing', 'Auditing', 'Proofreading',
+    'Measuring', 'Benchmarking', 'Stress-testing', 'Safeguarding', 'Hardening',
+    'Polishing', 'Fine-tuning', 'Checking', 'Confirming', 'Certifying',
+  ]),
+  Processing: Object.freeze([
+    'Reading', 'Parsing', 'Indexing', 'Remembering', 'Recalling',
+    'Organizing', 'Classifying', 'Filtering', 'Sorting', 'Matching',
+    'Merging', 'Summarizing', 'Compressing', 'Transforming', 'Learning',
+  ]),
+  Collaborating: Object.freeze([
+    'Delegating', 'Collaborating', 'Consulting', 'Briefing', 'Dispatching',
+    'Synchronizing', 'Negotiating', 'Handshaking', 'Queuing', 'Routing',
+    'Supervising', 'Monitoring', 'Reconciling', 'Reporting', 'Converging',
+  ]),
+  Creating: Object.freeze([
+    'Writing', 'Rewriting', 'Translating', 'Localizing', 'Narrating',
+    'Explaining', 'Illustrating', 'Visualizing', 'Formatting', 'Styling',
+    'Presenting', 'Documenting', 'Captioning', 'Storyboarding', 'Publishing',
+  ]),
+  'BLUN Magic': Object.freeze([
+    'BLUNing', 'Sparkering', 'Wondermaking', 'Dreamweaving', 'Futurecrafting',
+    'Brightening', 'Flowing', 'Accelerating', 'Automating', 'Empowering',
+    'Launching', 'Scaling', 'Evolving', 'Delivering', 'Finishing',
+  ]),
+});
+
+const EVIDENCE_KEYS = new Set([
+  'command', 'cmd', 'description', 'file', 'file_path', 'path', 'pattern',
+  'prompt', 'query', 'task', 'title', 'url',
+]);
+
+function activityEvidence(toolCall) {
+  if (!toolCall || typeof toolCall !== 'object') return '';
+  const values = [toolCall.name];
+  const args = toolCall.args;
+  if (args && typeof args === 'object' && !Array.isArray(args)) {
+    for (const [key, value] of Object.entries(args)) {
+      if (!EVIDENCE_KEYS.has(key.toLowerCase())) continue;
+      if (typeof value === 'string') values.push(value.slice(0, 2_000));
+    }
+  } else if (typeof toolCall.argumentsText === 'string') {
+    values.push(toolCall.argumentsText.slice(0, 2_000));
+  }
+  return values.filter(Boolean).join(' ').toLowerCase();
+}
+
+function matchesAny(text, patterns) {
+  return patterns.some((pattern) => text.includes(pattern));
+}
+
+function inferThinkingActivityGroup(toolCall, options = {}) {
+  if (options.completing === true) return 'BLUN Magic';
+  if (options.retrying === true || options.failed === true) return 'Solving';
+
+  const name = typeof toolCall?.name === 'string' ? toolCall.name.toLowerCase() : '';
+  const evidence = activityEvidence(toolCall);
+  if (!name) return 'Thinking';
+  if (name === 'todolist' || matchesAny(evidence, [' plan', 'roadmap', 'architect', 'scope'])) return 'Planning';
+  if (matchesAny(name, ['agent', 'swarm', 'telegram']) || matchesAny(evidence, ['delegate', 'handoff', 'telegram', 'report to'])) return 'Collaborating';
+  if (matchesAny(name, ['mnemo', 'memory', 'compact']) || matchesAny(evidence, ['memory', 'mnemo', 'compact', 'summar', 'index'])) return 'Processing';
+  if (matchesAny(name, ['grep', 'glob', 'search', 'webfetch', 'web_fetch', 'websearch', 'web_search', 'ls']) || matchesAny(evidence, ['search', 'find ', 'inspect', 'trace'])) return 'Researching';
+  if (matchesAny(evidence, ['publish', 'release', 'deploy', 'launch', 'deliver', 'finish'])) return 'BLUN Magic';
+  if (matchesAny(evidence, ['error', 'fail', 'debug', 'diagnos', 'repair', 'patch', 'fix ', 'recover', 'troubleshoot'])) return 'Solving';
+  if (matchesAny(evidence, ['test', 'check', 'verify', 'validat', 'audit', 'benchmark', 'measure', 'compare', 'sha256', 'diff '])) return 'Validating';
+  if (name === 'read' || name === 'readbatch') return 'Processing';
+  if (name === 'write' || name === 'edit') {
+    if (matchesAny(evidence, ['.md', '.txt', 'readme', 'changelog', 'document', 'translat', 'localiz'])) return 'Creating';
+    return 'Building';
+  }
+  if (matchesAny(name, ['bash', 'shell', 'programmatictool']) || matchesAny(evidence, ['build', 'compile', 'npm ', 'node ', 'code'])) return 'Building';
+  return 'Processing';
+}
+
+class ThinkingActivityRotator {
+  constructor(changeIntervalMs = ACTIVITY_CHANGE_INTERVAL_MS) {
+    this.changeIntervalMs = Math.max(ACTIVITY_CHANGE_INTERVAL_MS, Number(changeIntervalMs) || 0);
+    this.currentWord = undefined;
+    this.changedAtMs = undefined;
+    this.nextIndexByGroup = new Map();
+  }
+
+  resolve(group, nowMs = Date.now()) {
+    const safeGroup = Object.hasOwn(THINKING_ACTIVITY_WORDS, group) ? group : 'Thinking';
+    const now = Number.isFinite(nowMs) ? nowMs : Date.now();
+    if (this.currentWord !== undefined && now - this.changedAtMs < this.changeIntervalMs) return this.currentWord;
+
+    const words = THINKING_ACTIVITY_WORDS[safeGroup];
+    const index = this.nextIndexByGroup.get(safeGroup) ?? 0;
+    this.currentWord = words[index % words.length];
+    this.nextIndexByGroup.set(safeGroup, (index + 1) % words.length);
+    this.changedAtMs = now;
+    return this.currentWord;
+  }
+}
+
+module.exports = {
+  ACTIVITY_CHANGE_INTERVAL_MS,
+  THINKING_ACTIVITY_WORDS,
+  ThinkingActivityRotator,
+  inferThinkingActivityGroup,
+};

package/bin/thinking-only-guard.cjs

@@ -0,0 +1,75 @@
+'use strict';
+
+const DEFAULT_THINKING_ONLY_LIMIT_MS = 10 * 60 * 1000;
+const FORCE_ANSWER_PROMPT = [
+  'Stop hidden thinking now and answer with the concrete finding, blocker, or next action.',
+  'Do not call tools and do not ask for another task.',
+].join(' ');
+
+function createThinkingOnlyGuard(options = {}) {
+  const maxMs = options.maxMs ?? DEFAULT_THINKING_ONLY_LIMIT_MS;
+  const now = options.now ?? Date.now;
+  const setTimer = options.setTimer ?? setTimeout;
+  const clearTimer = options.clearTimer ?? clearTimeout;
+  const onTimeout = options.onTimeout ?? (() => {});
+  let timer;
+  let startedAt;
+  let substantiveOutput = false;
+
+  function disarm() {
+    if (timer !== undefined) clearTimer(timer);
+    timer = undefined;
+    startedAt = undefined;
+  }
+
+  function beginAttempt() {
+    disarm();
+    substantiveOutput = false;
+  }
+
+  function noteThinking() {
+    if (substantiveOutput || timer !== undefined) return;
+    startedAt = now();
+    timer = setTimer(() => {
+      timer = undefined;
+      const elapsedMs = Math.max(0, now() - startedAt);
+      startedAt = undefined;
+      onTimeout({ reason: 'thinking_only_timeout', elapsedMs });
+    }, maxMs);
+    timer?.unref?.();
+  }
+
+  function noteSubstantiveOutput() {
+    substantiveOutput = true;
+    disarm();
+  }
+
+  return {
+    beginAttempt,
+    noteThinking,
+    noteSubstantiveOutput,
+    stop: disarm,
+  };
+}
+
+function forceAnswerParams(params) {
+  return {
+    ...params,
+    tools: [],
+    messages: [
+      ...params.messages,
+      {
+        role: 'user',
+        content: [{ type: 'text', text: FORCE_ANSWER_PROMPT }],
+        toolCalls: [],
+      },
+    ],
+  };
+}
+
+module.exports = {
+  DEFAULT_THINKING_ONLY_LIMIT_MS,
+  FORCE_ANSWER_PROMPT,
+  createThinkingOnlyGuard,
+  forceAnswerParams,
+};

package/bin/tool-call-loop-policy.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+const { createHash } = require('node:crypto');
+
+const FORCE_ANSWER_RESULT_STREAK = 3;
+const NUMBER_VALUE = '<number>';
+const NUMBER_TEXT = /[-+]?(?:\d+(?:\.\d+)?|\.\d+)(?:e[-+]?\d+)?/giu;
+
+function normalizeLoopText(value) {
+  return String(value).toLowerCase().replace(NUMBER_TEXT, NUMBER_VALUE);
+}
+
+function normalizeLoopValue(value) {
+  if (typeof value === 'number' || typeof value === 'bigint') return NUMBER_VALUE;
+  if (typeof value === 'string') return normalizeLoopText(value);
+  if (Array.isArray(value)) return value.map(normalizeLoopValue);
+  if (value === null || typeof value !== 'object') return value;
+
+  const normalized = {};
+  for (const key of Object.keys(value).sort((left, right) => left.localeCompare(right))) {
+    normalized[key.toLowerCase()] = normalizeLoopValue(value[key]);
+  }
+  return normalized;
+}
+
+function createToolCallLoopKey(toolName, args) {
+  return `${normalizeLoopText(toolName)} ${JSON.stringify(normalizeLoopValue(args))}`;
+}
+
+function hashToolResult(result) {
+  const normalized = normalizeResultValue({
+    isError: result?.isError === true,
+    output: result?.output,
+  });
+  return createHash('sha256').update(JSON.stringify(normalized)).digest('hex');
+}
+
+function normalizeResultValue(value) {
+  if (Array.isArray(value)) return value.map(normalizeResultValue);
+  if (value === null || typeof value !== 'object') return value;
+  const normalized = {};
+  for (const key of Object.keys(value).sort((left, right) => left.localeCompare(right))) {
+    normalized[key] = normalizeResultValue(value[key]);
+  }
+  return normalized;
+}
+
+module.exports = {
+  FORCE_ANSWER_RESULT_STREAK,
+  createToolCallLoopKey,
+  hashToolResult,
+  normalizeLoopValue,
+};

package/bin/turn-thinking-policy.cjs

@@ -7,8 +7,27 @@ const BOSNIAN_STANDALONE_CHAT = /^(?:zdravo|pozdrav|hvala|ćao|cao)[.!?]*$/iu;
 const IDENTITY_CHAT = /^(?:wer bist du|who are you|wie geht(?: es dir)?|how are you|na|kako si|kako je king|ko si ti|ko stoji iza tebe)[.!?]*$/iu;
 const STATUS_ONLY_CHECK_IN = /(?:\bstandabfrage\b|\bstatusabfrage\b|\bkurzes?\s+update\b|\bwo\s+stehst\s+du\b|\bwie\s+weit\s+bist\s+du\b|\bwhere\s+are\s+you\b|\bquick\s+status\b)/iu;
 const STATUS_FOLLOW_UP_ACTION = /\b(?:aendere|arbeite|baue|build|change|delete|deploy|deploye|fahr|fix|fixe|implement|implementiere|install|installiere|loesche|mach|patch|pruefe|repariere|run|schreibe|setze|start|starte|stop|stoppe|test|teste|write)\b/iu;
+const THINKING_EFFORT_RANK = Object.freeze({
+  none: 0,
+  off: 0,
+  low: 1,
+  medium: 2,
+  high: 3,
+  xhigh: 4,
+  max: 5,
+});
 
-function selectThinkingEffortForTurn(text, originKind) {
+function keepOnlyEffortIncrease(selectedEffort, profileEffort) {
+  if (selectedEffort === undefined || profileEffort === undefined || profileEffort === null) {
+    return selectedEffort;
+  }
+  const selectedRank = THINKING_EFFORT_RANK[selectedEffort];
+  const profileRank = THINKING_EFFORT_RANK[profileEffort];
+  if (selectedRank === undefined || profileRank === undefined || selectedRank <= profileRank) return undefined;
+  return selectedEffort;
+}
+
+function classifyThinkingEffortForTurn(text, originKind) {
   if (originKind !== "user") return undefined;
 
   const normalized = String(text ?? "").replace(/\s+/gu, " ").trim();
@@ -30,6 +49,10 @@ function selectThinkingEffortForTurn(text, originKind) {
   return shortQuestion ? "low" : undefined;
 }
 
+function selectThinkingEffortForTurn(text, originKind, profileEffort) {
+  return keepOnlyEffortIncrease(classifyThinkingEffortForTurn(text, originKind), profileEffort);
+}
+
 function shouldEnableThinkingForTurn(text, originKind) {
   return selectThinkingEffortForTurn(text, originKind) !== "off";
 }
@@ -59,6 +82,7 @@ module.exports = {
   ACTIONABLE_PROMPT,
   EXPLICIT_THINKING_INTENT,
   capCompletionBudgetForAdaptiveEffort,
+  keepOnlyEffortIncrease,
   selectThinkingEffortForBufferedSteer,
   selectThinkingEffortForWorkStep,
   selectThinkingEffortForTurn,