blun-king-cli 9.1.485 → 9.1.488

package/bin/turn-tool-performance-policy.cjs

@@ -17,6 +17,12 @@ const TOOL_SEARCH_INTENT_WORDS = new Set([
   'find', 'fetch', 'get', 'holen', 'list', 'read', 'search', 'show', 'anzeigen', 'lesen', 'suchen',
 ]);
 const TOOL_SEARCH_RELATED_TERM_GROUPS = Object.freeze([
+  Object.freeze([
+    'checklist', 'list', 'liste', 'listen',
+  ]),
+  Object.freeze([
+    'aufgabe', 'aufgaben', 'aufgabenliste', 'todo', 'todos',
+  ]),
   Object.freeze([
     'current', 'inbox', 'latest', 'message', 'messages', 'nachricht', 'nachrichten', 'queue', 'queued',
     'recent', 'letzte', 'letzten', 'letzter', 'vergangen', 'update', 'updates',
@@ -195,7 +201,10 @@ function rankingTokens(value) {
 function toolRankingDocument(tool) {
   const name = String(tool?.name || '');
   const leaf = name.split(/__|:/).at(-1) || name;
-  const nameTokens = rankingTokens(`${name.replaceAll('_', ' ')} ${leaf.replaceAll('_', ' ')}`);
+  const splitToolName = (value) => String(value || '')
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .replaceAll('_', ' ');
+  const nameTokens = rankingTokens(`${splitToolName(name)} ${splitToolName(leaf)}`);
   const descriptionTokens = rankingTokens(tool?.description);
   const parameterText = [];
   const properties = tool?.parameters?.properties;
@@ -247,14 +256,18 @@ function rankedToolNamesForTurnText(tools, value, options = {}) {
     let score = 0;
     let matchedTokens = 0;
     let exactNameMatches = 0;
+    let relatedNameMatches = 0;
     for (const token of queryTokens) {
       const tokenScore = tokenMatchScore(document, token);
       if (tokenScore === 0) continue;
       score += tokenScore;
       matchedTokens += 1;
       if (document.nameTokens.has(token)) exactNameMatches += 1;
+      else if (relatedSearchTerms(token).some((term) => document.nameTokens.has(term))) relatedNameMatches += 1;
     }
-    const highConfidence = matchedTokens >= 2 || (exactNameMatches >= 1 && score >= 10);
+    const highConfidence = matchedTokens >= 2
+      || (exactNameMatches >= 1 && score >= 10)
+      || (relatedNameMatches >= 1 && score >= 5);
     return highConfidence ? { name: document.name, score, matchedTokens, exactNameMatches } : null;
   }).filter(Boolean).sort((left, right) => (
     right.matchedTokens - left.matchedTokens

package/bin/update-notice.js

@@ -621,6 +621,54 @@ function installCommandText(version) {
   return `npm i -g ${PACKAGE_NAME}@${version}`;
 }
 
+function updateCopy(uiLocale) {
+  const german = String(uiLocale || '').toLowerCase().startsWith('de');
+  if (german) {
+    return {
+      available: (current, next) => `BLUN Code-Update verfügbar: ${current} -> ${next}`,
+      current: (version) => `Kein Update verfügbar. Installiert: ${version} · Aktuell: ${version}.`,
+      enter: 'Enter drücken, um fortzufahren',
+      failed: (code) => `Update fehlgeschlagen (Code ${code}).`,
+      install: (version) => `Jetzt aktualisieren (führt \`${installCommandText(version)}\` aus)`,
+      installFailed: (code) => `Update fehlgeschlagen (Code ${code}). Die vorhandene Version wird gestartet.`,
+      installed: 'Installation geprüft',
+      installedContinue: (current, next) => `Update ${current} -> ${next} erfolgreich installiert. Die letzte Sitzung wird mit der neuen Version fortgesetzt.`,
+      installedRestart: (current, next) => `Update ${current} -> ${next} erfolgreich installiert. Starte BLUN Code neu, um die neue Version zu verwenden.`,
+      installerReady: 'Installer bereit',
+      installing: 'Paket wird installiert',
+      invalidTarget: (version) => `Kein sicherer Update-Zielstand verfügbar. Installiert: ${version}.`,
+      nextRelease: 'Auf den nächsten Release warten',
+      notes: 'Versionshinweise',
+      skip: 'Überspringen',
+      startupNoticeFailed: (version) => `Update ${version} wurde installiert, aber die Startmeldung konnte nicht gespeichert werden.`,
+      updateChecked: 'Update geprüft',
+      verificationFailed: 'Das Update konnte nicht verifiziert werden.',
+      verificationRestart: 'Update konnte nicht verifiziert werden. Starte BLUN Code neu.',
+    };
+  }
+  return {
+    available: (current, next) => `BLUN Code update available: ${current} -> ${next}`,
+    current: (version) => `No update available. Installed: ${version} · Current: ${version}.`,
+    enter: 'Press Enter to continue',
+    failed: (code) => `Update failed (code ${code}).`,
+    install: (version) => `Update now (runs \`${installCommandText(version)}\`)`,
+    installFailed: (code) => `Update failed (code ${code}). The installed version will start.`,
+    installed: 'Installation verified',
+    installedContinue: (current, next) => `Update ${current} -> ${next} installed successfully. The last session will continue with the new version.`,
+    installedRestart: (current, next) => `Update ${current} -> ${next} installed successfully. Restart BLUN Code to use the new version.`,
+    installerReady: 'Installer ready',
+    installing: 'Installing package',
+    invalidTarget: (version) => `No safe update target is available. Installed: ${version}.`,
+    nextRelease: 'Wait for the next release',
+    notes: 'Release notes',
+    skip: 'Skip',
+    startupNoticeFailed: (version) => `Update ${version} was installed, but the startup notice could not be saved.`,
+    updateChecked: 'Update checked',
+    verificationFailed: 'The update could not be verified.',
+    verificationRestart: 'The update could not be verified. Restart BLUN Code.',
+  };
+}
+
 function createUpdateProgress(output) {
   const enabled = output?.isTTY === true;
   const phaseCount = 4;
@@ -646,7 +694,14 @@ function createUpdateProgress(output) {
   return update;
 }
 
-function promptUpdateAction({ currentVersion, release, input, output, processRef = process }) {
+function promptUpdateAction({
+  currentVersion,
+  release,
+  input,
+  output,
+  processRef = process,
+  uiLocale = 'en',
+}) {
   return new Promise((resolve, reject) => {
     let selected = 0;
     let settled = false;
@@ -659,13 +714,14 @@ function promptUpdateAction({ currentVersion, release, input, output, processRef
     const dim = '\u001B[2m';
     const underline = '\u001B[4m';
     const reset = '\u001B[0m';
+    const copy = updateCopy(uiLocale);
     const actions = [
       {
         choice: 'install',
-        label: `Jetzt aktualisieren (führt \`${installCommandText(release.version)}\` aus)`,
+        label: copy.install(release.version),
       },
-      { choice: 'skip-once', label: 'Überspringen' },
-      { choice: 'skip-version', label: 'Auf den nächsten Release warten' },
+      { choice: 'skip-once', label: copy.skip },
+      { choice: 'skip-version', label: copy.nextRelease },
     ];
     const signalHandlers = new Map();
 
@@ -675,7 +731,7 @@ function promptUpdateAction({ currentVersion, release, input, output, processRef
         const line = `${selected === index ? '›' : ' '} ${index + 1}. ${actions[index].label}`;
         output.write(`\r\u001B[2K${selected === index ? cyan : ''}${line}${selected === index ? reset : ''}\n`);
       }
-      output.write(`\r\u001B[2K${dim}Enter drücken, um fortzufahren${reset}\n`);
+      output.write(`\r\u001B[2K${dim}${copy.enter}${reset}\n`);
     };
     const cleanup = () => {
       if (escapeTimer !== undefined) clearTimeout(escapeTimer);
@@ -830,9 +886,9 @@ function promptUpdateAction({ currentVersion, release, input, output, processRef
         signalHandlers.set(signal, handler);
         processRef.once(signal, handler);
       }
-      output.write(`\nBLUN Code-Update verfügbar: ${currentVersion} -> ${release.version}\n`);
+      output.write(`\n${copy.available(currentVersion, release.version)}\n`);
       if (release.notesUrl) {
-        output.write(`${dim}Versionshinweise:${reset} ${underline}${release.notesUrl}${reset}\n`);
+        output.write(`${dim}${copy.notes}:${reset} ${underline}${release.notesUrl}${reset}\n`);
       }
       output.write('\n');
       cursorHidden = true;
@@ -1290,19 +1346,21 @@ function noReleaseReason(currentVersion, registryTags, fallbackManifest) {
   return parseSemver(latest) || fallbackManifest ? 'current' : 'unavailable';
 }
 
-function explicitNoTarget(stdout, reason, currentVersion) {
+function explicitNoTarget(stdout, reason, currentVersion, uiLocale) {
+  const copy = updateCopy(uiLocale);
   stdout.write(reason === 'current'
-    ? `Kein Update verfügbar. Installiert: ${currentVersion} · Aktuell: ${currentVersion}.\n`
-    : `Kein sicherer Update-Zielstand verfügbar. Installiert: ${currentVersion}.\n`);
+    ? `${copy.current(currentVersion)}\n`
+    : `${copy.invalidTarget(currentVersion)}\n`);
   return { kind: 'current', reason };
 }
 
-function explicitFailure(stderr, reason, exitCode) {
+function explicitFailure(stderr, reason, exitCode, uiLocale) {
+  const copy = updateCopy(uiLocale);
   const hasExitCode = Number.isInteger(exitCode) && exitCode !== 0;
   if (hasExitCode) {
-    stderr.write(`Update fehlgeschlagen (Code ${exitCode}).\n`);
+    stderr.write(`${copy.failed(exitCode)}\n`);
   } else {
-    stderr.write('Das Update konnte nicht verifiziert werden.\n');
+    stderr.write(`${copy.verificationFailed}\n`);
   }
   return {
     kind: 'failed',
@@ -1321,12 +1379,14 @@ async function runUpdateFlow(options, explicitUpdate) {
     stderr,
     blunDir,
   } = options;
+  const uiLocale = options.uiLocale || 'en';
+  const copy = updateCopy(uiLocale);
   if (!explicitUpdate && !isInteractiveUpdateStart({ argv, env, stdin, stdout })) {
     return { kind: 'continue', reason: 'not_interactive' };
   }
   if (!parseSemver(currentVersion)) {
     return explicitUpdate
-      ? explicitFailure(stderr, 'invalid_current_version')
+      ? explicitFailure(stderr, 'invalid_current_version', undefined, uiLocale)
       : { kind: 'continue', reason: 'invalid_current_version' };
   }
 
@@ -1340,7 +1400,7 @@ async function runUpdateFlow(options, explicitUpdate) {
       leaseResult = await (options.acquireLease || tryAcquireUpdateLease)({ packageRoot });
     } catch {
       return explicitUpdate
-        ? explicitFailure(stderr, 'lease_unavailable')
+        ? explicitFailure(stderr, 'lease_unavailable', undefined, uiLocale)
         : { kind: 'continue', reason: 'lease_unavailable' };
     }
   } else {
@@ -1351,6 +1411,8 @@ async function runUpdateFlow(options, explicitUpdate) {
       return explicitFailure(
         stderr,
         leaseResult?.reason === 'busy' ? 'update_in_progress' : 'lease_unavailable',
+        undefined,
+        uiLocale,
       );
     }
     return leaseResult?.reason === 'busy'
@@ -1366,7 +1428,7 @@ async function runUpdateFlow(options, explicitUpdate) {
       sources = await (options.loadReleaseSources || loadReleaseSources)();
     } catch {
       return explicitUpdate
-        ? explicitNoTarget(stdout, 'unavailable', currentVersion)
+        ? explicitNoTarget(stdout, 'unavailable', currentVersion, uiLocale)
         : { kind: 'continue', reason: 'unavailable' };
     }
     const registryTags = parseRegistryDocument(sources?.registryDocument);
@@ -1375,7 +1437,7 @@ async function runUpdateFlow(options, explicitUpdate) {
     if (!release) {
       const reason = noReleaseReason(currentVersion, registryTags, fallbackManifest);
       return explicitUpdate
-        ? explicitNoTarget(stdout, reason, currentVersion)
+        ? explicitNoTarget(stdout, reason, currentVersion, uiLocale)
         : { kind: 'continue', reason };
     }
     if (!explicitUpdate
@@ -1385,12 +1447,12 @@ async function runUpdateFlow(options, explicitUpdate) {
     const initialInstallLease = await probeInstallLease(options, packageRoot);
     if (initialInstallLease === 'busy') {
       return explicitUpdate
-        ? explicitFailure(stderr, 'update_in_progress')
+        ? explicitFailure(stderr, 'update_in_progress', undefined, uiLocale)
         : { kind: 'update_in_progress' };
     }
     if (initialInstallLease !== 'clear') {
       return explicitUpdate
-        ? explicitFailure(stderr, 'lease_unavailable')
+        ? explicitFailure(stderr, 'lease_unavailable', undefined, uiLocale)
         : { kind: 'continue', reason: 'lease_unavailable' };
     }
     if (!explicitUpdate
@@ -1401,25 +1463,25 @@ async function runUpdateFlow(options, explicitUpdate) {
       try {
         ensurePrivateDirectory(blunDir);
       } catch {
-        return explicitFailure(stderr, 'private_home_unavailable');
+        return explicitFailure(stderr, 'private_home_unavailable', undefined, uiLocale);
       }
     }
     try {
       lease.assertOwned();
     } catch {
       return explicitUpdate
-        ? explicitFailure(stderr, 'update_in_progress')
+        ? explicitFailure(stderr, 'update_in_progress', undefined, uiLocale)
         : { kind: 'update_in_progress' };
     }
     const prePromptInstallLease = await probeInstallLease(options, packageRoot);
     if (prePromptInstallLease === 'busy') {
       return explicitUpdate
-        ? explicitFailure(stderr, 'update_in_progress')
+        ? explicitFailure(stderr, 'update_in_progress', undefined, uiLocale)
         : { kind: 'update_in_progress' };
     }
     if (prePromptInstallLease !== 'clear') {
       return explicitUpdate
-        ? explicitFailure(stderr, 'lease_unavailable')
+        ? explicitFailure(stderr, 'lease_unavailable', undefined, uiLocale)
         : { kind: 'continue', reason: 'lease_unavailable' };
     }
     if (!options.installVersion) {
@@ -1429,7 +1491,7 @@ async function runUpdateFlow(options, explicitUpdate) {
       );
       if (!installerSession?.ready) {
         if (explicitUpdate) {
-          return explicitFailure(stderr, 'installer_unavailable');
+          return explicitFailure(stderr, 'installer_unavailable', undefined, uiLocale);
         }
         return installerSession?.reason === 'failed'
           ? { kind: 'continue', reason: 'installer_unavailable' }
@@ -1437,7 +1499,7 @@ async function runUpdateFlow(options, explicitUpdate) {
       }
     }
     let action;
-    if (explicitUpdate) {
+    if (explicitUpdate || options.autoInstall === true) {
       action = 'install';
     } else {
       try {
@@ -1446,6 +1508,7 @@ async function runUpdateFlow(options, explicitUpdate) {
           release,
           input: stdin,
           output: stdout,
+          uiLocale,
         });
       } catch {
         return { kind: 'continue', reason: 'prompt_failed' };
@@ -1476,18 +1539,18 @@ async function runUpdateFlow(options, explicitUpdate) {
     }
 
     const updateProgress = createUpdateProgress(stdout);
-    updateProgress(1, 'Update geprüft');
-    updateProgress(2, 'Installer bereit');
+    updateProgress(1, copy.updateChecked);
+    updateProgress(2, copy.installerReady);
 
     try {
       lease.assertOwned();
     } catch {
       return explicitUpdate
-        ? explicitFailure(stderr, 'update_in_progress')
+        ? explicitFailure(stderr, 'update_in_progress', undefined, uiLocale)
         : { kind: 'update_in_progress' };
     }
     let installResult;
-    updateProgress(3, 'Paket wird installiert');
+    updateProgress(3, copy.installing);
     try {
       installResult = options.installVersion
         ? await options.installVersion(release.version)
@@ -1500,11 +1563,11 @@ async function runUpdateFlow(options, explicitUpdate) {
       || installResult?.unknownState === true) {
       updateProgress.finish();
       return explicitUpdate
-        ? explicitFailure(stderr, 'update_in_progress')
+        ? explicitFailure(stderr, 'update_in_progress', undefined, uiLocale)
         : { kind: 'update_in_progress' };
     }
     if (installResult?.code === 0 && installResult?.verified === true) {
-      updateProgress(4, 'Installation geprüft');
+      updateProgress(4, copy.installed);
       clearPendingUpdate(blunDir);
       try {
         writeCoreInstallSuccess(
@@ -1512,21 +1575,19 @@ async function runUpdateFlow(options, explicitUpdate) {
           currentVersion,
           release.version,
           release.releaseNotes,
-          explicitUpdate ? 'manual' : 'startup_prompt',
+          explicitUpdate ? 'manual' : options.autoInstall === true ? 'startup_auto' : 'startup_prompt',
           (options.now || Date.now)(),
         );
       } catch {
-        stderr.write(
-          `Update ${release.version} wurde installiert, aber die Startmeldung konnte nicht gespeichert werden.\n`,
-        );
+        stderr.write(`${copy.startupNoticeFailed(release.version)}\n`);
       }
       const continuesLastSession = Array.isArray(options.argv)
         && options.argv.length === 1
         && options.argv[0] === '-c';
-      stdout.write(continuesLastSession
-        ? `Update ${currentVersion} -> ${release.version} erfolgreich installiert. Die letzte Sitzung wird mit der neuen Version fortgesetzt.\n`
-        : `Update ${currentVersion} -> ${release.version} erfolgreich installiert. Starte BLUN Code neu, um die neue Version zu verwenden.\n`);
-      if (release.notesUrl) stdout.write(`Versionshinweise: ${release.notesUrl}\n`);
+      stdout.write(`${continuesLastSession
+        ? copy.installedContinue(currentVersion, release.version)
+        : copy.installedRestart(currentVersion, release.version)}\n`);
+      if (release.notesUrl) stdout.write(`${copy.notes}: ${release.notesUrl}\n`);
       return {
         kind: 'installed',
         version: release.version,
@@ -1536,14 +1597,14 @@ async function runUpdateFlow(options, explicitUpdate) {
     if (Number.isInteger(installResult?.code) && installResult.code !== 0) {
       updateProgress.finish();
       if (explicitUpdate) {
-        return explicitFailure(stderr, 'install_failed', installResult.code);
+        return explicitFailure(stderr, 'install_failed', installResult.code, uiLocale);
       }
-      stderr.write(`Update fehlgeschlagen (Code ${installResult.code}). Die vorhandene Version wird gestartet.\n`);
+      stderr.write(`${copy.installFailed(installResult.code)}\n`);
       return { kind: 'continue', reason: 'install_failed', exitCode: installResult.code };
     }
     updateProgress.finish();
-    if (explicitUpdate) return explicitFailure(stderr, 'verification_failed');
-    stderr.write('Update konnte nicht verifiziert werden. Starte BLUN Code neu.\n');
+    if (explicitUpdate) return explicitFailure(stderr, 'verification_failed', undefined, uiLocale);
+    stderr.write(`${copy.verificationRestart}\n`);
     return { kind: 'update_in_progress' };
   } finally {
     if (installerSession?.ready) {