blun-king-cli 9.1.536 → 9.1.550

package/codebase-index/README.md

@@ -31,6 +31,18 @@ python codebase_index.py query  <repo> "wo wird die retry-Kappe gesetzt?"
 python codebase_index.py sample <repo>
 ```
 
+`query` und `sample` waehlen standardmaessig `--model auto`: Ein vorhandener
+Jina-Code-Index wird wegen des gemessenen 3/3-Qualitaetsgates bevorzugt, ein
+vorhandener BGE-Index bleibt Fallback. `--model jina-code` und `--model bge`
+waehlen explizit. Build und Update bleiben modellgebunden und akzeptieren kein
+`auto`.
+
+Vorhandene Indizes werden ueber die kanonische Repository-Identitaet im
+Manifest gefunden, auch wenn ein aelterer BLUN-Stand einen anderen
+Workspace-Hash als Ordnernamen erzeugt hat. Fremde Repositories, unbekannte
+Modelle, falsche Dimensionen, fehlende Vektordateien und Links aus dem
+Index-State heraus werden ignoriert.
+
 Index-Ort: `~/.blun/codebase-index/<workspace-hash>/` mit
 `vectors.npy` (float32-Matrix), `manifest.json` (Hashes, Spans, Meta,
 Stand) und `query-log.jsonl` (jede Query — der Moat: welche Begriffe

package/codebase-index/codebase_index.py

@@ -1,8 +1,7 @@
 #!/usr/bin/env python3
 """codebase-index — lokaler semantischer Index ueber einen Git-Code-Baum.
 
-F1-Bau nach Konzept (handoffs/codebase-verstaendnis-lokal-konzept.md),
-Auflagen Dieter 43102:
+Lokaler Index nach dem geprueften Streaming-Konzept:
 - Streaming in vorallokierte float32-Matrix (memmap), KEINE Vektoren-Liste
   (Run-3-Befund: Liste trieb RAM-Spitze auf 10,5 GB).
 - Inkrementell: Content-Hash je Datei im Manifest, Delta statt Vollindex.
@@ -36,8 +35,18 @@ CHUNK_OVERLAP = 100
 EMBED_DIM = 384
 BATCH = 256
 MODEL_NAME = "BAAI/bge-small-en-v1.5"
-
-# Iteration 2 (Dieter 43135): Rausch-Filter — Backup-Kopien und Vendor-
+JINA_CODE_MODEL_NAME = "jinaai/jina-embeddings-v2-base-code"
+KNOWN_MODELS = {
+    MODEL_NAME: 384,
+    JINA_CODE_MODEL_NAME: 768,
+}
+MODEL_ALIASES = {
+    "bge": MODEL_NAME,
+    "jina-code": JINA_CODE_MODEL_NAME,
+}
+AUTO_MODEL_ORDER = (JINA_CODE_MODEL_NAME, MODEL_NAME)
+
+# Rausch-Filter: Backup-Kopien und Vendor-
 # Buelle machten 66% aller Index-Rows aus und dominieren Top-5.
 EXCLUDE_PREFIXES = ("backup-", "vendor/")
 
@@ -45,7 +54,7 @@ EXCLUDE_PREFIXES = ("backup-", "vendor/")
 _active_model_name = MODEL_NAME
 _active_dim = EMBED_DIM
 
-# Stichprobe V3 (Dieter 43141): Fragen PARAPHRASIERT aus gelesenem
+# Stichprobe: Fragen PARAPHRASIERT aus gelesenem
 # Dateiinhalt — keine wörtlichen Bezeichner/Funktionsnamen/Kommentare aus
 # den Dateien (misst semantische Suche, nicht Wortgleichheit).
 # api-chat.js: routet Chat-Nachrichten ans Modell, Fallback-Kette, Stream.
@@ -63,10 +72,96 @@ SELSTAUSKUNFT = (
 )
 
 
+def canonical_repo_path(repo: str) -> str:
+    return os.path.normcase(os.path.realpath(os.path.abspath(repo)))
+
+
+def index_root() -> str:
+    return os.path.join(os.path.expanduser("~"), ".blun", "codebase-index")
+
+
 def index_dir(repo: str) -> str:
-    raw = os.path.abspath(repo) + "|" + _active_model_name
+    raw = canonical_repo_path(repo) + "|" + _active_model_name
     key = hashlib.sha256(raw.encode()).hexdigest()[:12]
-    return os.path.join(os.path.expanduser("~"), ".blun", "codebase-index", key)
+    return os.path.join(index_root(), key)
+
+
+def normalize_model_selector(selector: str) -> str:
+    if selector == "auto":
+        return selector
+    model = MODEL_ALIASES.get(selector, selector)
+    if model not in KNOWN_MODELS:
+        allowed = ", ".join(("auto", *MODEL_ALIASES, *KNOWN_MODELS))
+        raise ValueError(f"Unsupported index model {selector!r}; choose one of: {allowed}")
+    return model
+
+
+def find_existing_indexes(repo: str) -> list[tuple[str, dict]]:
+    root = index_root()
+    if not os.path.isdir(root):
+        return []
+    canonical_repo = canonical_repo_path(repo)
+    canonical_root = os.path.realpath(root)
+    candidates = []
+    for entry in os.scandir(root):
+        if not entry.is_dir(follow_symlinks=False):
+            continue
+        directory = os.path.realpath(entry.path)
+        try:
+            if os.path.commonpath((canonical_root, directory)) != canonical_root:
+                continue
+        except ValueError:
+            continue
+        manifest_path = os.path.join(directory, "manifest.json")
+        vectors_path = os.path.join(directory, "vectors.npy")
+        if not os.path.isfile(manifest_path) or not os.path.isfile(vectors_path):
+            continue
+        try:
+            manifest = load_manifest(directory)
+        except (OSError, ValueError, TypeError):
+            continue
+        model = manifest.get("model")
+        if model not in KNOWN_MODELS or manifest.get("dim") != KNOWN_MODELS[model]:
+            continue
+        manifest_repo = manifest.get("repo")
+        if not isinstance(manifest_repo, str):
+            continue
+        if canonical_repo_path(manifest_repo) != canonical_repo:
+            continue
+        candidates.append((directory, manifest))
+    return sorted(candidates, key=lambda item: item[0])
+
+
+def resolve_existing_index(repo: str, selector: str = "auto") -> tuple[str, dict]:
+    requested = normalize_model_selector(selector)
+    candidates = find_existing_indexes(repo)
+    model_order = AUTO_MODEL_ORDER if requested == "auto" else (requested,)
+    for model in model_order:
+        matches = [item for item in candidates if item[1]["model"] == model]
+        if matches:
+            return max(
+                matches,
+                key=lambda item: (str(item[1].get("built_at", "")), item[0]),
+            )
+    available = sorted({item[1]["model"] for item in candidates})
+    suffix = f"; available for this repository: {', '.join(available)}" if available else ""
+    raise FileNotFoundError(
+        f"No compatible codebase index for {os.path.abspath(repo)!r} and selector {selector!r}{suffix}"
+    )
+
+
+def activate_model(model: str, dim: int | None = None) -> None:
+    global _active_model_name, _active_dim
+    normalized = normalize_model_selector(model)
+    if normalized == "auto":
+        raise ValueError("auto can select an existing index only; it cannot build a new one")
+    expected_dim = KNOWN_MODELS[normalized]
+    if dim is not None and dim != expected_dim:
+        raise ValueError(
+            f"Index dimension {dim} does not match {normalized} ({expected_dim})"
+        )
+    _active_model_name = normalized
+    _active_dim = expected_dim
 
 
 def git_files(repo: str) -> list[str]:
@@ -261,9 +356,9 @@ def freshness(repo: str, man: dict) -> str:
     return f"Index-Stand: {man['head']} ({man['built_at']}), {man['chunks']} Chunks | {same}"
 
 
-def cmd_query(repo: str, question: str, top: int) -> int:
-    dirpath = index_dir(repo)
-    man = load_manifest(dirpath)
+def cmd_query(repo: str, question: str, top: int, selector: str = "auto") -> int:
+    dirpath, man = resolve_existing_index(repo, selector)
+    activate_model(man["model"], man["dim"])
     mat = np.load(os.path.join(dirpath, "vectors.npy"))
     norms = np.linalg.norm(mat, axis=1, keepdims=True)
     mat_n = mat / np.maximum(norms, 1e-12)
@@ -278,6 +373,7 @@ def cmd_query(repo: str, question: str, top: int) -> int:
 
     hits = [(man["meta"][i], round(float(scores[i]), 4)) for i in idx]
     print(SELSTAUSKUNFT)
+    print(f"Index-Modell: {man['model']}")
     print(freshness(repo, man))
     for m, s in hits:
         print(f"  {s:.4f}  {m}")
@@ -295,10 +391,10 @@ def cmd_query(repo: str, question: str, top: int) -> int:
     return 0
 
 
-def cmd_sample(repo: str) -> int:
+def cmd_sample(repo: str, selector: str = "auto") -> int:
     """Gate: Stichprobe aus dem Subjekt-Baum, Ziel >= 2/3 in Top-5."""
-    dirpath = index_dir(repo)
-    man = load_manifest(dirpath)
+    dirpath, man = resolve_existing_index(repo, selector)
+    activate_model(man["model"], man["dim"])
     mat = np.load(os.path.join(dirpath, "vectors.npy"))
     norms = np.linalg.norm(mat, axis=1, keepdims=True)
     mat_n = mat / np.maximum(norms, 1e-12)
@@ -326,8 +422,16 @@ def main() -> int:
     if len(sys.argv) < 3:
         print(__doc__)
         return 2
-    if "--model" in sys.argv:
-        _active_model_name = sys.argv[sys.argv.index("--model") + 1]
+    cmd, repo = sys.argv[1], sys.argv[2]
+    selector = sys.argv[sys.argv.index("--model") + 1] if "--model" in sys.argv else (
+        "auto" if cmd in ("query", "sample") else MODEL_NAME
+    )
+    if cmd in ("build", "update"):
+        try:
+            activate_model(selector)
+        except ValueError as error:
+            print(f"MODEL_ERROR {error}")
+            return 2
         from fastembed import TextEmbedding
 
         dims = {m["model"]: m.get("dim") for m in TextEmbedding.list_supported_models()}
@@ -336,7 +440,6 @@ def main() -> int:
             return 2
         _active_dim = int(dims[_active_model_name])
         print(f"MODEL {_active_model_name} dim={_active_dim}")
-    cmd, repo = sys.argv[1], sys.argv[2]
     if cmd == "build":
         cmd_build(repo)
         return 0
@@ -347,9 +450,17 @@ def main() -> int:
         top = 5
         if "--top" in sys.argv:
             top = int(sys.argv[sys.argv.index("--top") + 1])
-        return cmd_query(repo, sys.argv[3], top)
+        try:
+            return cmd_query(repo, sys.argv[3], top, selector)
+        except (FileNotFoundError, ValueError) as error:
+            print(f"INDEX_ERROR {error}")
+            return 2
     if cmd == "sample":
-        return cmd_sample(repo)
+        try:
+            return cmd_sample(repo, selector)
+        except (FileNotFoundError, ValueError) as error:
+            print(f"INDEX_ERROR {error}")
+            return 2
     print(f"unknown command: {cmd}")
     return 2
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.536",
+  "version": "9.1.550",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {
@@ -8,10 +8,7 @@
     "king": "bin/king.js"
   },
   "scripts": {
-    "test": "node --test test/*.test.js",
-    "prepack": "node scripts/check-release-metadata.js && node scripts/check-current-turn-read-pin-regression.js && node scripts/check-current-turn-read-pin-mutation-regression.js && node scripts/check-active-work-steer-regression.js && node scripts/check-empty-response-effort-downgrade-regression.js && node scripts/check-tool-schema-capacity-regression.js && node scripts/check-history-pressure-offload-regression.js && node scripts/check-startup-swarm-command-regression.js && node scripts/check-telegram-direct-work-resume-regression.js && node scripts/check-fredrik-glm-regression.js && node scripts/check-fredrik-model-picker-regression.js && node scripts/check-fredrik-glm-mutation-regression.js && node scripts/check-deepseek-native-max-regression.js && node scripts/check-programmatic-tool-regression.js && node scripts/check-programmatic-context-isolation-regression.js && node scripts/check-structured-subagent-output-regression.js && node scripts/check-codebase-search-packaging-regression.js && node scripts/check-copy-command-regression.js && node scripts/check-shell-terminal-isolation-regression.js && node scripts/check-todo-loop-regression.js && node scripts/check-todo-progress-regression.js && node scripts/check-telegram-loop-exactly-once-regression.js && node scripts/check-session-picker-resume-metrics-regression.js && node scripts/check-bundled-agent-spine-regression.js && node scripts/check-reload-agent-spine-regression.js && node scripts/check-todo-recovery-catalog-regression.js && node scripts/check-historical-tool-result-preview-regression.js && node scripts/check-session-start-hook-context-regression.js && node scripts/check-queue-controls-regression.js && node scripts/check-approval-queue-shortcuts-regression.js && node scripts/check-approval-observability-regression.js && node scripts/check-slash-escape-regression.js && node scripts/check-telegram-bridge-watchdog.js && node scripts/check-resume-replay-regression.js && node scripts/check-session-cancel-regression.js && node scripts/check-plugin-startup-regression.js && node scripts/check-active-profile-plugin-startup.js && node scripts/check-mcp-startup-wait-budget.js",
-    "release:verify": "node scripts/check-release-metadata.js --external",
-    "postinstall": "node scripts/fix-node-pty-perms.js"
+    "postinstall": "node bin/fix-node-pty-perms.js"
   },
   "engines": {
     "node": ">=24.15.0"
@@ -31,58 +28,27 @@
   },
   "files": [
     "bin/",
+    "!bin/package-regression-policy.cjs",
     "blun.mjs",
-    "codebase-index/",
+    "codebase-index/codebase_index.py",
+    "codebase-index/README.md",
     "dist-web/",
     "native/",
-    "release-planned-removals.json",
-    "scripts/check-package-regression.js",
-    "scripts/check-fredrik-glm-regression.js",
-    "scripts/check-fredrik-glm-mutation-regression.js",
-    "scripts/check-deepseek-native-max-regression.js",
-    "scripts/check-programmatic-tool-regression.js",
-    "scripts/check-programmatic-context-isolation-regression.js",
-    "scripts/programmatic-tool-runtime.test.mjs",
-    "scripts/check-structured-subagent-output-regression.js",
-    "scripts/structured-subagent-output.test.cjs",
-    "scripts/check-codebase-search-packaging-regression.js",
-    "scripts/check-copy-command-regression.js",
-    "scripts/check-active-profile-plugin-startup.js",
-    "scripts/check-approval-queue-shortcuts-regression.js",
-    "scripts/check-bundled-agent-spine-regression.js",
-    "scripts/check-reload-agent-spine-regression.js",
-    "scripts/check-approval-observability-regression.js",
-    "scripts/check-slash-escape-regression.js",
-    "scripts/check-mcp-startup-wait-budget.js",
-    "scripts/check-plugin-startup-regression.js",
-    "scripts/check-queue-controls-regression.js",
-    "scripts/check-telegram-bridge-watchdog.js",
-    "scripts/check-resume-replay-regression.js",
-    "scripts/check-session-cancel-regression.js",
-    "scripts/check-shell-terminal-isolation-regression.js",
-    "scripts/check-session-picker-resume-metrics-regression.js",
-    "scripts/check-release-metadata.js",
-    "scripts/check-historical-tool-result-preview-regression.js",
-    "scripts/check-current-turn-read-pin-regression.js",
-    "scripts/check-current-turn-read-pin-mutation-regression.js",
-    "scripts/check-active-work-steer-regression.js",
-    "scripts/check-empty-response-effort-downgrade-regression.js",
-    "scripts/check-tool-schema-capacity-regression.js",
-    "scripts/check-history-pressure-offload-regression.js",
-    "scripts/check-startup-swarm-command-regression.js",
-    "scripts/check-telegram-direct-work-resume-regression.js",
-    "scripts/check-session-start-hook-context-regression.js",
-    "scripts/check-telegram-loop-exactly-once-regression.js",
-    "scripts/check-todo-recovery-catalog-regression.js",
-    "scripts/check-todo-loop-regression.js",
-    "scripts/check-todo-progress-regression.js",
-    "scripts/fix-node-pty-perms.js",
     "standard-skills/",
     "standard-tools/",
-    "agent-spine-plugin/",
+    "agent-spine-plugin/.claude-plugin/",
+    "agent-spine-plugin/.codex-plugin/",
+    "agent-spine-plugin/.mcp.json",
+    "agent-spine-plugin/assets/",
+    "agent-spine-plugin/bin/",
+    "agent-spine-plugin/blun.plugin.json",
+    "agent-spine-plugin/hooks/",
+    "agent-spine-plugin/LICENSE",
+    "agent-spine-plugin/package.json",
+    "agent-spine-plugin/skill/",
+    "agent-spine-plugin/skills/",
+    "agent-spine-plugin/src/",
     "telegram-plugin/",
-    "fredrik-glm-profile.toml.example",
-    "CHANGELOG.md",
     "LIESMICH.txt"
   ],
   "keywords": [
@@ -94,14 +60,13 @@
   ],
   "author": "BLUN",
   "main": "index.js",
-  "directories": {
-    "test": "test"
-  },
   "type": "commonjs",
   "dependencies": {
-    "blun-king-cli": "^9.1.62",
+    "@mozilla/readability": "0.6.0",
+    "linkedom": "0.18.12",
     "node-addon-api": "^7.1.1",
-    "quickjs-emscripten": "0.32.0"
-  },
-  "devDependencies": {}
+    "quickjs-emscripten": "0.32.0",
+    "turndown": "7.2.4",
+    "turndown-plugin-gfm": "1.0.2"
+  }
 }

package/telegram-plugin/bin/telegram-typing-keepalive.cjs

@@ -0,0 +1,89 @@
+'use strict';
+
+const DEFAULT_INTERVAL_MS = 4_000;
+const DEFAULT_MAX_DURATION_MS = 30 * 60_000;
+
+function positiveInteger(value, fallback) {
+  return Number.isSafeInteger(value) && value > 0 ? value : fallback;
+}
+
+function createTelegramTypingKeepalive(options = {}) {
+  if (typeof options.sendTyping !== 'function') {
+    throw new TypeError('sendTyping must be a function');
+  }
+  if (typeof options.isComplete !== 'function') {
+    throw new TypeError('isComplete must be a function');
+  }
+
+  const now = typeof options.now === 'function' ? options.now : Date.now;
+  const setTimer = options.setTimer ?? setTimeout;
+  const clearTimer = options.clearTimer ?? clearTimeout;
+  const intervalMs = positiveInteger(options.intervalMs, DEFAULT_INTERVAL_MS);
+  const maxDurationMs = positiveInteger(options.maxDurationMs, DEFAULT_MAX_DURATION_MS);
+  const active = new Map();
+
+  function stop(chatIdValue) {
+    const chatId = String(chatIdValue);
+    const state = active.get(chatId);
+    if (state === undefined) return false;
+    if (state.timer !== undefined) clearTimer(state.timer);
+    active.delete(chatId);
+    return true;
+  }
+
+  function schedule(state) {
+    state.timer = setTimer(() => tick(state), intervalMs);
+    state.timer?.unref?.();
+  }
+
+  async function tick(state) {
+    if (active.get(state.chatId) !== state) return;
+    state.timer = undefined;
+    if (now() >= state.deadline || options.isComplete(state.marker, state.chatId)) {
+      stop(state.chatId);
+      return;
+    }
+    try {
+      await options.sendTyping(state.chatId);
+    } catch {}
+    if (active.get(state.chatId) !== state) return;
+    if (now() >= state.deadline || options.isComplete(state.marker, state.chatId)) {
+      stop(state.chatId);
+      return;
+    }
+    schedule(state);
+  }
+
+  function begin(chatIdValue, marker) {
+    const chatId = String(chatIdValue ?? '').trim();
+    if (chatId.length === 0) return false;
+    stop(chatId);
+    const state = {
+      chatId,
+      marker,
+      deadline: now() + maxDurationMs,
+      timer: undefined,
+    };
+    active.set(chatId, state);
+    void tick(state);
+    return true;
+  }
+
+  function dispose() {
+    for (const chatId of [...active.keys()]) stop(chatId);
+  }
+
+  return {
+    activeCount: () => active.size,
+    begin,
+    dispose,
+    has: (chatId) => active.has(String(chatId)),
+    stop,
+  };
+}
+
+module.exports = {
+  DEFAULT_INTERVAL_MS,
+  DEFAULT_MAX_DURATION_MS,
+  createTelegramTypingKeepalive,
+};

package/telegram-plugin/dist/bridge.mjs

@@ -13,6 +13,7 @@ import privateConversationPolicy from "../bin/telegram-private-conversation-poli
 import telegramTextChunkPolicy from "../bin/telegram-text-chunk-policy.cjs";
 import telegramMnemoCapture from "../bin/telegram-mnemo-capture.cjs";
 import telegramDeliveryLifecyclePolicy from "../bin/telegram-delivery-lifecycle.cjs";
+import telegramTypingKeepalivePolicy from "../bin/telegram-typing-keepalive.cjs";
 const { buildTelegramRemoteStatus, resolveTelegramQueueSnapshot, resolveTelegramRemoteVersion } = remoteStatusPolicy;
 const { parseTelegramConsoleStatus } = consoleStatusPolicy;
 const { buildTelegramApprovalCard, isAuthorizedTelegramApprovalCallback, listPendingTelegramApprovals, markTelegramApprovalSent, parseTelegramApprovalCallback, resolveTelegramApprovalTarget, wasTelegramApprovalSent, writeTelegramApprovalResponse } = telegramApprovalRelay;
@@ -20,6 +21,7 @@ const { findDuplicateReplyWithoutNewInbound, isPrivateInternalStatusReply, sanit
 const { sendTelegramTextChunks } = telegramTextChunkPolicy;
 const { createTelegramMnemoCapture } = telegramMnemoCapture;
 const { createTelegramDeliveryLifecycle, telegramDeliveryIdentity } = telegramDeliveryLifecyclePolicy;
+const { createTelegramTypingKeepalive } = telegramTypingKeepalivePolicy;
 //#region ../../node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
@@ -4650,6 +4652,10 @@ function alreadySeen(key) {
 const MAX_INBOUND_AGE_S = Number(process.env.BLUN_TELEGRAM_MAX_INBOUND_AGE_S ?? 900);
 const HEADLESS_ENABLED = (process.env.BLUN_TELEGRAM_HEADLESS ?? "on").trim().toLowerCase() !== "off";
 const deliveryLifecycle = createTelegramDeliveryLifecycle({ stateDir: stateDir() });
+const typingKeepalive = createTelegramTypingKeepalive({
+	sendTyping: (chatId) => bot.api.sendChatAction(chatId, "typing"),
+	isComplete: (marker, chatId) => outboxGrewForChat(marker, chatId)
+});
 let lastMnemoCaptureErrorAt = 0;
 const mnemoCapture = createTelegramMnemoCapture({
 	env: process.env,
@@ -4700,7 +4706,7 @@ async function handleInbound(event) {
 	const targetedElsewhere = result.action === "deliver" ? result.targetedElsewhere ?? false : false;
 	const priority = result.action === "deliver" ? result.priority : void 0;
 	if (addressed) {
-		bot.api.sendChatAction(chatId, "typing").catch(() => {});
+		typingKeepalive.begin(chatId, outboxMarker());
 		if (result.access.ackReaction !== void 0 && result.access.ackReaction !== "" && msgId !== void 0) bot.api.setMessageReaction(chatId, msgId, [{
 			type: "emoji",
 			emoji: result.access.ackReaction
@@ -4863,6 +4869,7 @@ function shutdown() {
 	shuttingDown = true;
 	process.stderr.write("telegram bridge: shutting down\n");
 	releasePollerPid();
+	typingKeepalive.dispose();
 	session.dispose();
 	setTimeout(() => process.exit(0), 2e3).unref();
 	Promise.resolve(bot.stop()).finally(() => process.exit(0));