@poolzin/pool-bot 2026.2.11 → 2026.2.18

package/dist/memory/qmd-query-parser.js

@@ -0,0 +1,107 @@
+import { createSubsystemLogger } from "../logging/subsystem.js";
+const log = createSubsystemLogger("memory");
+export function parseQmdQueryJson(stdout, stderr) {
+    const trimmedStdout = stdout.trim();
+    const trimmedStderr = stderr.trim();
+    const stdoutIsMarker = trimmedStdout.length > 0 && isQmdNoResultsOutput(trimmedStdout);
+    const stderrIsMarker = trimmedStderr.length > 0 && isQmdNoResultsOutput(trimmedStderr);
+    if (stdoutIsMarker || (!trimmedStdout && stderrIsMarker)) {
+        return [];
+    }
+    if (!trimmedStdout) {
+        const context = trimmedStderr ? ` (stderr: ${summarizeQmdStderr(trimmedStderr)})` : "";
+        const message = `stdout empty${context}`;
+        log.warn(`qmd query returned invalid JSON: ${message}`);
+        throw new Error(`qmd query returned invalid JSON: ${message}`);
+    }
+    try {
+        const parsed = parseQmdQueryResultArray(trimmedStdout);
+        if (parsed !== null) {
+            return parsed;
+        }
+        const noisyPayload = extractFirstJsonArray(trimmedStdout);
+        if (!noisyPayload) {
+            throw new Error("qmd query JSON response was not an array");
+        }
+        const fallback = parseQmdQueryResultArray(noisyPayload);
+        if (fallback !== null) {
+            return fallback;
+        }
+        throw new Error("qmd query JSON response was not an array");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        log.warn(`qmd query returned invalid JSON: ${message}`);
+        throw new Error(`qmd query returned invalid JSON: ${message}`, { cause: err });
+    }
+}
+function isQmdNoResultsOutput(raw) {
+    const lines = raw
+        .split(/\r?\n/)
+        .map((line) => line.trim().toLowerCase().replace(/\s+/g, " "))
+        .filter((line) => line.length > 0);
+    return lines.some((line) => isQmdNoResultsLine(line));
+}
+function isQmdNoResultsLine(line) {
+    if (line === "no results found" || line === "no results found.") {
+        return true;
+    }
+    return /^(?:\[[^\]]+\]\s*)?(?:(?:warn(?:ing)?|info|error|qmd)\s*:\s*)+no results found\.?$/.test(line);
+}
+function summarizeQmdStderr(raw) {
+    return raw.length <= 120 ? raw : `${raw.slice(0, 117)}...`;
+}
+function parseQmdQueryResultArray(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function extractFirstJsonArray(raw) {
+    const start = raw.indexOf("[");
+    if (start < 0) {
+        return null;
+    }
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < raw.length; i += 1) {
+        const char = raw[i];
+        if (char === undefined) {
+            break;
+        }
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (char === "\\") {
+                escaped = true;
+            }
+            else if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            continue;
+        }
+        if (char === "[") {
+            depth += 1;
+        }
+        else if (char === "]") {
+            depth -= 1;
+            if (depth === 0) {
+                return raw.slice(start, i + 1);
+            }
+        }
+    }
+    return null;
+}

package/dist/memory/qmd-scope.js

@@ -0,0 +1,93 @@
+import { parseAgentSessionKey } from "../sessions/session-key-utils.js";
+export function isQmdScopeAllowed(scope, sessionKey) {
+    if (!scope) {
+        return true;
+    }
+    const parsed = parseQmdSessionScope(sessionKey);
+    const channel = parsed.channel;
+    const chatType = parsed.chatType;
+    const normalizedKey = parsed.normalizedKey ?? "";
+    const rawKey = sessionKey?.trim().toLowerCase() ?? "";
+    for (const rule of scope.rules ?? []) {
+        if (!rule) {
+            continue;
+        }
+        const match = rule.match ?? {};
+        if (match.channel && match.channel !== channel) {
+            continue;
+        }
+        if (match.chatType && match.chatType !== chatType) {
+            continue;
+        }
+        const normalizedPrefix = match.keyPrefix?.trim().toLowerCase() || undefined;
+        const rawPrefix = match.keyPrefix?.trim().toLowerCase() || undefined;
+        if (rawPrefix && !rawKey.startsWith(rawPrefix)) {
+            continue;
+        }
+        if (normalizedPrefix) {
+            // Backward compat: older configs used `keyPrefix: "agent:<id>:..."` to match raw keys.
+            const isLegacyRaw = normalizedPrefix.startsWith("agent:");
+            if (isLegacyRaw) {
+                if (!rawKey.startsWith(normalizedPrefix)) {
+                    continue;
+                }
+            }
+            else if (!normalizedKey.startsWith(normalizedPrefix)) {
+                continue;
+            }
+        }
+        return rule.action === "allow";
+    }
+    const fallback = scope.default ?? "allow";
+    return fallback === "allow";
+}
+export function deriveQmdScopeChannel(key) {
+    return parseQmdSessionScope(key).channel;
+}
+export function deriveQmdScopeChatType(key) {
+    return parseQmdSessionScope(key).chatType;
+}
+function parseQmdSessionScope(key) {
+    const normalized = normalizeQmdSessionKey(key);
+    if (!normalized) {
+        return {};
+    }
+    const parts = normalized.split(":").filter(Boolean);
+    let chatType;
+    if (parts.length >= 2 &&
+        (parts[1] === "group" || parts[1] === "channel" || parts[1] === "direct" || parts[1] === "dm")) {
+        if (parts.includes("group")) {
+            chatType = "group";
+        }
+        else if (parts.includes("channel")) {
+            chatType = "channel";
+        }
+        return {
+            normalizedKey: normalized,
+            channel: parts[0]?.toLowerCase(),
+            chatType: chatType ?? "direct",
+        };
+    }
+    if (normalized.includes(":group:")) {
+        return { normalizedKey: normalized, chatType: "group" };
+    }
+    if (normalized.includes(":channel:")) {
+        return { normalizedKey: normalized, chatType: "channel" };
+    }
+    return { normalizedKey: normalized, chatType: "direct" };
+}
+function normalizeQmdSessionKey(key) {
+    if (!key) {
+        return undefined;
+    }
+    const trimmed = key.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const parsed = parseAgentSessionKey(trimmed);
+    const normalized = (parsed?.rest ?? trimmed).toLowerCase();
+    if (normalized.startsWith("subagent:")) {
+        return undefined;
+    }
+    return normalized;
+}

package/dist/memory/query-expansion.js

@@ -0,0 +1,331 @@
+/**
+ * Query expansion for FTS-only search mode.
+ *
+ * When no embedding provider is available, we fall back to FTS (full-text search).
+ * FTS works best with specific keywords, but users often ask conversational queries
+ * like "that thing we discussed yesterday" or "之前讨论的那个方案".
+ *
+ * This module extracts meaningful keywords from such queries to improve FTS results.
+ */
+// Common stop words that don't add search value
+const STOP_WORDS_EN = new Set([
+    // Articles and determiners
+    "a",
+    "an",
+    "the",
+    "this",
+    "that",
+    "these",
+    "those",
+    // Pronouns
+    "i",
+    "me",
+    "my",
+    "we",
+    "our",
+    "you",
+    "your",
+    "he",
+    "she",
+    "it",
+    "they",
+    "them",
+    // Common verbs
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "can",
+    "may",
+    "might",
+    // Prepositions
+    "in",
+    "on",
+    "at",
+    "to",
+    "for",
+    "of",
+    "with",
+    "by",
+    "from",
+    "about",
+    "into",
+    "through",
+    "during",
+    "before",
+    "after",
+    "above",
+    "below",
+    "between",
+    "under",
+    "over",
+    // Conjunctions
+    "and",
+    "or",
+    "but",
+    "if",
+    "then",
+    "because",
+    "as",
+    "while",
+    "when",
+    "where",
+    "what",
+    "which",
+    "who",
+    "how",
+    "why",
+    // Time references (vague, not useful for FTS)
+    "yesterday",
+    "today",
+    "tomorrow",
+    "earlier",
+    "later",
+    "recently",
+    "before",
+    "ago",
+    "just",
+    "now",
+    // Vague references
+    "thing",
+    "things",
+    "stuff",
+    "something",
+    "anything",
+    "everything",
+    "nothing",
+    // Question words
+    "please",
+    "help",
+    "find",
+    "show",
+    "get",
+    "tell",
+    "give",
+]);
+const STOP_WORDS_ZH = new Set([
+    // Pronouns
+    "我",
+    "我们",
+    "你",
+    "你们",
+    "他",
+    "她",
+    "它",
+    "他们",
+    "这",
+    "那",
+    "这个",
+    "那个",
+    "这些",
+    "那些",
+    // Auxiliary words
+    "的",
+    "了",
+    "着",
+    "过",
+    "得",
+    "地",
+    "吗",
+    "呢",
+    "吧",
+    "啊",
+    "呀",
+    "嘛",
+    "啦",
+    // Verbs (common, vague)
+    "是",
+    "有",
+    "在",
+    "被",
+    "把",
+    "给",
+    "让",
+    "用",
+    "到",
+    "去",
+    "来",
+    "做",
+    "说",
+    "看",
+    "找",
+    "想",
+    "要",
+    "能",
+    "会",
+    "可以",
+    // Prepositions and conjunctions
+    "和",
+    "与",
+    "或",
+    "但",
+    "但是",
+    "因为",
+    "所以",
+    "如果",
+    "虽然",
+    "而",
+    "也",
+    "都",
+    "就",
+    "还",
+    "又",
+    "再",
+    "才",
+    "只",
+    // Time (vague)
+    "之前",
+    "以前",
+    "之后",
+    "以后",
+    "刚才",
+    "现在",
+    "昨天",
+    "今天",
+    "明天",
+    "最近",
+    // Vague references
+    "东西",
+    "事情",
+    "事",
+    "什么",
+    "哪个",
+    "哪些",
+    "怎么",
+    "为什么",
+    "多少",
+    // Question/request words
+    "请",
+    "帮",
+    "帮忙",
+    "告诉",
+]);
+/**
+ * Check if a token looks like a meaningful keyword.
+ * Returns false for short tokens, numbers-only, etc.
+ */
+function isValidKeyword(token) {
+    if (!token || token.length === 0) {
+        return false;
+    }
+    // Skip very short English words (likely stop words or fragments)
+    if (/^[a-zA-Z]+$/.test(token) && token.length < 3) {
+        return false;
+    }
+    // Skip pure numbers (not useful for semantic search)
+    if (/^\d+$/.test(token)) {
+        return false;
+    }
+    // Skip tokens that are all punctuation
+    if (/^[\p{P}\p{S}]+$/u.test(token)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Simple tokenizer that handles both English and Chinese text.
+ * For Chinese, we do character-based splitting since we don't have a proper segmenter.
+ * For English, we split on whitespace and punctuation.
+ */
+function tokenize(text) {
+    const tokens = [];
+    const normalized = text.toLowerCase().trim();
+    // Split into segments (English words, Chinese character sequences, etc.)
+    const segments = normalized.split(/[\s\p{P}]+/u).filter(Boolean);
+    for (const segment of segments) {
+        // Check if segment contains CJK characters
+        if (/[\u4e00-\u9fff]/.test(segment)) {
+            // For Chinese, extract character n-grams (unigrams and bigrams)
+            const chars = Array.from(segment).filter((c) => /[\u4e00-\u9fff]/.test(c));
+            // Add individual characters
+            tokens.push(...chars);
+            // Add bigrams for better phrase matching
+            for (let i = 0; i < chars.length - 1; i++) {
+                tokens.push(chars[i] + chars[i + 1]);
+            }
+        }
+        else {
+            // For non-CJK, keep as single token
+            tokens.push(segment);
+        }
+    }
+    return tokens;
+}
+/**
+ * Extract keywords from a conversational query for FTS search.
+ *
+ * Examples:
+ * - "that thing we discussed about the API" → ["discussed", "API"]
+ * - "之前讨论的那个方案" → ["讨论", "方案"]
+ * - "what was the solution for the bug" → ["solution", "bug"]
+ */
+export function extractKeywords(query) {
+    const tokens = tokenize(query);
+    const keywords = [];
+    const seen = new Set();
+    for (const token of tokens) {
+        // Skip stop words
+        if (STOP_WORDS_EN.has(token) || STOP_WORDS_ZH.has(token)) {
+            continue;
+        }
+        // Skip invalid keywords
+        if (!isValidKeyword(token)) {
+            continue;
+        }
+        // Skip duplicates
+        if (seen.has(token)) {
+            continue;
+        }
+        seen.add(token);
+        keywords.push(token);
+    }
+    return keywords;
+}
+/**
+ * Expand a query for FTS search.
+ * Returns both the original query and extracted keywords for OR-matching.
+ *
+ * @param query - User's original query
+ * @returns Object with original query and extracted keywords
+ */
+export function expandQueryForFts(query) {
+    const original = query.trim();
+    const keywords = extractKeywords(original);
+    // Build expanded query: original terms OR extracted keywords
+    // This ensures both exact matches and keyword matches are found
+    const expanded = keywords.length > 0 ? `${original} OR ${keywords.join(" OR ")}` : original;
+    return { original, keywords, expanded };
+}
+/**
+ * Expand query with optional LLM assistance.
+ * Falls back to local extraction if LLM is unavailable or fails.
+ */
+export async function expandQueryWithLlm(query, llmExpander) {
+    // If LLM expander is provided, try it first
+    if (llmExpander) {
+        try {
+            const llmKeywords = await llmExpander(query);
+            if (llmKeywords.length > 0) {
+                return llmKeywords;
+            }
+        }
+        catch {
+            // LLM failed, fall back to local extraction
+        }
+    }
+    // Fall back to local keyword extraction
+    return extractKeywords(query);
+}

package/dist/memory/search-manager.js

@@ -11,7 +11,6 @@ export async function getMemorySearchManager(params) {
             return { manager: cached };
         }
         try {
-            // @ts-expect-error qmd-manager is an optional module that may not exist at build time
             const { QmdMemoryManager } = await import("./qmd-manager.js");
             const primary = await QmdMemoryManager.create({
                 cfg: params.cfg,

package/dist/memory/sync-index.js

@@ -0,0 +1,21 @@
+function tickProgress(progress) {
+    if (!progress) {
+        return;
+    }
+    progress.completed += 1;
+    progress.report({
+        completed: progress.completed,
+        total: progress.total,
+    });
+}
+export async function indexFileEntryIfChanged(params) {
+    const record = params.db
+        .prepare(`SELECT hash FROM files WHERE path = ? AND source = ?`)
+        .get(params.entry.path, params.source);
+    if (!params.needsFullReindex && record?.hash === params.entry.hash) {
+        tickProgress(params.progress);
+        return;
+    }
+    await params.indexFile(params.entry);
+    tickProgress(params.progress);
+}

package/dist/memory/sync-progress.js

@@ -0,0 +1,22 @@
+export function bumpSyncProgressTotal(progress, delta, label) {
+    if (!progress) {
+        return;
+    }
+    progress.total += delta;
+    progress.report({
+        completed: progress.completed,
+        total: progress.total,
+        label,
+    });
+}
+export function bumpSyncProgressCompleted(progress, delta = 1, label) {
+    if (!progress) {
+        return;
+    }
+    progress.completed += delta;
+    progress.report({
+        completed: progress.completed,
+        total: progress.total,
+        label,
+    });
+}

package/dist/memory/sync-stale.js

@@ -0,0 +1,30 @@
+export function deleteStaleIndexedPaths(params) {
+    const staleRows = params.db
+        .prepare(`SELECT path FROM files WHERE source = ?`)
+        .all(params.source);
+    for (const stale of staleRows) {
+        if (params.activePaths.has(stale.path)) {
+            continue;
+        }
+        params.db
+            .prepare(`DELETE FROM files WHERE path = ? AND source = ?`)
+            .run(stale.path, params.source);
+        try {
+            params.db
+                .prepare(`DELETE FROM ${params.vectorTable} WHERE id IN (SELECT id FROM chunks WHERE path = ? AND source = ?)`)
+                .run(stale.path, params.source);
+        }
+        catch { }
+        params.db
+            .prepare(`DELETE FROM chunks WHERE path = ? AND source = ?`)
+            .run(stale.path, params.source);
+        if (params.ftsEnabled && params.ftsAvailable) {
+            try {
+                params.db
+                    .prepare(`DELETE FROM ${params.ftsTable} WHERE path = ? AND source = ? AND model = ?`)
+                    .run(stale.path, params.source, params.model);
+            }
+            catch { }
+        }
+    }
+}