@yeaft/webchat-agent 1.0.216 → 1.0.217

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.216"}
+{"version":"1.0.217"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.216",
+  "version": "1.0.217",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/conversation/search.js

@@ -1,7 +1,7 @@
 /**
  * search.js — Conversation history search
  *
- * Simple keyword search across hot and cold messages.
+ * Bounded content search across hot and cold messages.
  */
 
 import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
@@ -18,36 +18,77 @@ function parseJsonLine(line) {
   }
 }
 
+function normalizeTerms(keyword) {
+  return String(keyword || '')
+    .trim()
+    .toLocaleLowerCase()
+    .split(/\s+/u)
+    .filter(Boolean);
+}
+
+function searchableContent(msg) {
+  if (typeof msg?.content === 'string') return msg.content;
+  if (Array.isArray(msg?.content)) {
+    return msg.content
+      .map(block => typeof block === 'string' ? block : (block?.text || ''))
+      .filter(Boolean)
+      .join('\n');
+  }
+  return '';
+}
+
+function matchesMessage(msg, terms) {
+  if (!msg || msg.role === 'tool') return false;
+  const content = searchableContent(msg).toLocaleLowerCase();
+  return content.length > 0 && terms.every(term => content.includes(term));
+}
+
+function recordFileScan(telemetry, raw) {
+  if (!telemetry) return;
+  telemetry.scannedFiles += 1;
+  telemetry.scannedBytes += Buffer.byteLength(raw, 'utf8');
+}
+
+function recordMessageScan(telemetry) {
+  if (telemetry) telemetry.scannedMessages += 1;
+}
+
+function withSource(msg, source) {
+  return {
+    ...msg,
+    content: searchableContent(msg),
+    sessionId: msg.sessionId || source.sessionId || null,
+    historySource: source.kind,
+  };
+}
+
 /**
- * Search Markdown messages in a directory for a keyword.
- *
- * @param {string} dir — messages directory
- * @param {string} keyword — search term (case-insensitive)
- * @returns {object[]} — matching messages
+ * Search Markdown messages in one directory, newest first.
  */
-function searchMarkdownDir(dir, keyword) {
+function searchMarkdownDir(dir, terms, limit, source, telemetry) {
   if (!existsSync(dir)) return [];
 
-  const lowerKeyword = keyword.toLowerCase();
   const files = readdirSync(dir)
     .filter(f => f.endsWith('.md'))
     .sort()
-    .reverse(); // newest first within one directory
+    .reverse();
 
   const results = [];
   for (const file of files) {
+    if (results.length >= limit) break;
     const raw = readFileSync(join(dir, file), 'utf8');
-    if (!raw.toLowerCase().includes(lowerKeyword)) continue;
-
+    recordFileScan(telemetry, raw);
+    recordMessageScan(telemetry);
+    const lowerRaw = raw.toLocaleLowerCase();
+    if (!terms.every(term => lowerRaw.includes(term))) continue;
     const msg = parseMessage(raw);
-    if (msg) results.push(msg);
+    if (matchesMessage(msg, terms)) results.push(withSource(msg, source));
   }
   return results;
 }
 
-function searchSegmentDir(dir, keyword) {
+function searchSegmentDir(dir, terms, limit, source, telemetry) {
   if (!existsSync(dir)) return [];
-  const lowerKeyword = keyword.toLowerCase();
   const files = readdirSync(dir)
     .filter(f => f.endsWith('.jsonl'))
     .sort()
@@ -55,24 +96,30 @@ function searchSegmentDir(dir, keyword) {
 
   const results = [];
   for (const file of files) {
+    if (results.length >= limit) break;
     const raw = readFileSync(join(dir, file), 'utf8');
-    if (!raw.toLowerCase().includes(lowerKeyword)) continue;
+    recordFileScan(telemetry, raw);
+    const lowerRaw = raw.toLocaleLowerCase();
+    if (!terms.every(term => lowerRaw.includes(term))) continue;
     const lines = raw.split('\n');
     for (let i = lines.length - 1; i >= 0; i -= 1) {
-      const line = lines[i];
-      if (!line || !line.toLowerCase().includes(lowerKeyword)) continue;
-      const msg = parseJsonLine(line);
-      if (msg) results.push(msg);
+      if (results.length >= limit) break;
+      if (!lines[i]?.trim()) continue;
+      recordMessageScan(telemetry);
+      const msg = parseJsonLine(lines[i]);
+      if (matchesMessage(msg, terms)) results.push(withSource(msg, source));
     }
   }
   return results;
 }
 
 function compareNewest(a, b) {
+  const timeComparison = String(b?.time || b?.timestamp || '').localeCompare(String(a?.time || a?.timestamp || ''));
+  if (timeComparison !== 0) return timeComparison;
+  if (a?.sessionId !== b?.sessionId || a?.historySource !== b?.historySource) return 0;
   const sa = parseSeqFromId(a?.id);
   const sb = parseSeqFromId(b?.id);
-  if (Number.isFinite(sa) && Number.isFinite(sb) && sa !== sb) return sb - sa;
-  return String(b?.time || '').localeCompare(String(a?.time || ''));
+  return Number.isFinite(sa) && Number.isFinite(sb) ? sb - sa : 0;
 }
 
 function sessionConversationDirs(dir) {
@@ -92,40 +139,56 @@ function sessionConversationDirs(dir) {
       const conversationDir = join(sessionDir, 'conversation');
       if (seen.has(conversationDir)) continue;
       seen.add(conversationDir);
-      dirs.push(conversationDir);
+      dirs.push({ dir: conversationDir, sessionId: name, kind: rootName === 'sessions' ? 'session' : 'legacy-session' });
     }
   }
   return dirs;
 }
 
 /**
- * Search Yeaft history (chat + per-session + legacy conversation) for a keyword.
+ * Search Yeaft history (chat + per-session + legacy conversation) by content.
+ * Whitespace-separated terms use AND semantics. Tool messages are excluded.
  *
  * @param {string} dir — Yeaft root directory (e.g. ~/.yeaft)
- * @param {string} keyword — search term
- * @param {number} [limit=20] — max results
+ * @param {string} keyword — search terms
+ * @param {number} [limit=10] — max results
+ * @param {{telemetry?: {scannedFiles?: number, scannedBytes?: number, scannedMessages?: number}}} [options]
  * @returns {object[]} — matching messages, newest first
  */
-export function searchMessages(dir, keyword, limit = 20) {
-  if (!keyword || !keyword.trim()) return [];
+export function searchMessages(dir, keyword, limit = 10, options = {}) {
+  const terms = normalizeTerms(keyword);
+  if (terms.length === 0) return [];
+
+  const resultLimit = Math.max(1, Math.min(100, Math.floor(Number(limit) || 10)));
+  const telemetry = options.telemetry || null;
+  if (telemetry) {
+    telemetry.scannedFiles = 0;
+    telemetry.scannedBytes = 0;
+    telemetry.scannedMessages = 0;
+  }
 
   const conversationDirs = [
-    join(dir, 'chat'),
+    { dir: join(dir, 'chat'), sessionId: null, kind: 'chat' },
     ...sessionConversationDirs(dir),
   ];
 
   const markdownDirs = [
-    ...conversationDirs.flatMap(d => [join(d, 'messages'), join(d, 'cold')]),
-    // Compatibility for profiles created before chat/session split.
-    join(dir, 'conversation', 'messages'),
-    join(dir, 'conversation', 'cold'),
+    ...conversationDirs.flatMap(source => [
+      { ...source, dir: join(source.dir, 'messages') },
+      { ...source, dir: join(source.dir, 'cold') },
+    ]),
+    { dir: join(dir, 'conversation', 'messages'), sessionId: null, kind: 'legacy-conversation' },
+    { dir: join(dir, 'conversation', 'cold'), sessionId: null, kind: 'legacy-conversation' },
   ];
-  const segmentDirs = conversationDirs.map(d => join(d, 'segments'));
+  const segmentDirs = conversationDirs.map(source => ({ ...source, dir: join(source.dir, 'segments') }));
 
-  return [
-    ...segmentDirs.flatMap(d => searchSegmentDir(d, keyword)),
-    ...markdownDirs.flatMap(d => searchMarkdownDir(d, keyword)),
+  const results = [
+    ...segmentDirs.flatMap(source => searchSegmentDir(source.dir, terms, resultLimit, source, telemetry)),
+    ...markdownDirs.flatMap(source => searchMarkdownDir(source.dir, terms, resultLimit, source, telemetry)),
   ]
     .sort(compareNewest)
-    .slice(0, limit);
+    .slice(0, resultLimit);
+
+  if (telemetry) telemetry.resultCount = results.length;
+  return results;
 }

package/yeaft/tools/history-search.js

@@ -8,20 +8,144 @@
 import { defineTool } from './types.js';
 import { searchMessages } from '../conversation/search.js';
 
+const DEFAULT_RESULT_LIMIT = 10;
+const MAX_SNIPPET_CHARS = 1000;
+export const HISTORY_SEARCH_MAX_OUTPUT_BYTES = 32 * 1024;
+
+function truncateUtf8(text, maxBytes) {
+  if (maxBytes <= 0) return '';
+  const buffer = Buffer.from(String(text), 'utf8');
+  if (buffer.length <= maxBytes) return String(text);
+  let end = maxBytes;
+  while (end > 0 && (buffer[end] & 0xc0) === 0x80) end -= 1;
+  return buffer.subarray(0, end).toString('utf8');
+}
+
+function isHighSurrogate(codeUnit) {
+  return codeUnit >= 0xd800 && codeUnit <= 0xdbff;
+}
+
+function isLowSurrogate(codeUnit) {
+  return codeUnit >= 0xdc00 && codeUnit <= 0xdfff;
+}
+
+function lowercaseWithOriginalOffsets(text) {
+  const fullLower = text.toLocaleLowerCase();
+  const lowerParts = [];
+  const originalOffsets = [];
+  for (let offset = 0; offset < text.length;) {
+    const codePoint = String.fromCodePoint(text.codePointAt(offset));
+    const loweredCodePoint = codePoint.toLocaleLowerCase();
+    lowerParts.push(loweredCodePoint);
+    for (let i = 0; i < loweredCodePoint.length; i += 1) originalOffsets.push(offset);
+    offset += codePoint.length;
+  }
+
+  const mappedLower = lowerParts.join('');
+  return {
+    lower: mappedLower.length === fullLower.length ? fullLower : mappedLower,
+    originalOffsets,
+  };
+}
+
+function buildSnippet(content, keyword, maxChars = MAX_SNIPPET_CHARS) {
+  const text = String(content || '');
+  if (text.length <= maxChars) return text;
+
+  const terms = String(keyword || '').trim().toLocaleLowerCase().split(/\s+/u).filter(Boolean);
+  const { lower, originalOffsets } = lowercaseWithOriginalOffsets(text);
+  const positions = terms.map(term => lower.indexOf(term)).filter(pos => pos >= 0);
+  const transformedMatchAt = positions.length > 0 ? Math.min(...positions) : 0;
+  const matchAt = originalOffsets[transformedMatchAt] ?? 0;
+  let start = Math.max(0, Math.min(matchAt - Math.floor(maxChars / 3), text.length - maxChars));
+  let end = Math.min(text.length, start + maxChars);
+
+  if (start > 0 && isLowSurrogate(text.charCodeAt(start)) && isHighSurrogate(text.charCodeAt(start - 1))) {
+    start -= 1;
+  }
+  if (end < text.length && isLowSurrogate(text.charCodeAt(end)) && isHighSurrogate(text.charCodeAt(end - 1))) {
+    end -= 1;
+  }
+
+  return `${start > 0 ? '...' : ''}${text.slice(start, end)}${end < text.length ? '...' : ''}`;
+}
+
+export function serializeHistorySearchOutput(payload, maxBytes = HISTORY_SEARCH_MAX_OUTPUT_BYTES) {
+  const serialize = value => JSON.stringify(value, null, 2);
+  let output = serialize(payload);
+  if (Buffer.byteLength(output, 'utf8') <= maxBytes) return output;
+
+  const originalResultCount = payload.results.length;
+  const bounded = {
+    ...payload,
+    results: [],
+    truncated: true,
+    omittedResults: originalResultCount,
+  };
+
+  for (const result of payload.results) {
+    const candidate = {
+      ...bounded,
+      results: [...bounded.results, result],
+      omittedResults: originalResultCount - bounded.results.length - 1,
+    };
+    const candidateOutput = serialize(candidate);
+    if (Buffer.byteLength(candidateOutput, 'utf8') <= maxBytes) {
+      bounded.results.push(result);
+      bounded.omittedResults -= 1;
+      continue;
+    }
+
+    const emptyContentCandidate = {
+      ...candidate,
+      results: [...bounded.results, { ...result, content: '' }],
+    };
+    const emptyOutput = serialize(emptyContentCandidate);
+    if (Buffer.byteLength(emptyOutput, 'utf8') > maxBytes) break;
+
+    let low = 0;
+    let high = Buffer.byteLength(result.content || '', 'utf8');
+    let best = '';
+    while (low <= high) {
+      const mid = Math.floor((low + high) / 2);
+      const content = truncateUtf8(result.content || '', mid);
+      const partialOutput = serialize({
+        ...candidate,
+        results: [...bounded.results, { ...result, content }],
+      });
+      if (Buffer.byteLength(partialOutput, 'utf8') <= maxBytes) {
+        best = content;
+        low = mid + 1;
+      } else {
+        high = mid - 1;
+      }
+    }
+    bounded.results.push({ ...result, content: best });
+    bounded.omittedResults -= 1;
+    break;
+  }
+
+  output = serialize(bounded);
+  if (Buffer.byteLength(output, 'utf8') > maxBytes) {
+    throw new Error('History search output metadata exceeds the 32 KiB budget');
+  }
+  return output;
+}
+
 export default defineTool({
   name: 'HistorySearch',
   description: {
     en: `Search through past conversation history.
 
-Searches for keywords in previously persisted conversation messages.
-Useful for finding previous discussions, decisions, or code snippets.
+Searches message content for all whitespace-separated terms (case-insensitive).
+Tool-result messages are excluded. Useful for finding previous discussions, decisions, or code snippets.
 
-Results are returned newest-first with message role and content.`,
+Results are returned newest-first with a bounded matching snippet and source metadata.`,
     zh: `搜索历史对话记录。
 
-在已持久化的对话消息中按关键词搜索。用于查找之前的讨论、决策或代码片段。
+在已持久化消息的正文中搜索全部空格分隔的关键词（不区分大小写），并排除工具结果消息。用于查找之前的讨论、决策或代码片段。
 
-结果按最新优先返回，包含消息角色和内容。`
+结果按最新优先返回，包含有界的命中片段和来源信息。`
   },
   parameters: {
     type: 'object',
@@ -29,15 +153,15 @@ Results are returned newest-first with message role and content.`,
       keyword: {
         type: 'string',
         description: {
-          en: 'Search keyword (case-insensitive)',
-          zh: '搜索关键词（不区分大小写）',
+          en: 'Search terms (case-insensitive, whitespace-separated terms use AND semantics)',
+          zh: '搜索关键词（不区分大小写，空格分隔的多个词采用 AND 语义）',
         },
       },
       limit: {
         type: 'number',
         description: {
-          en: 'Maximum number of results (default: 20)',
-          zh: '最多返回结果数（默认 20）',
+          en: 'Maximum number of results (default: 10, maximum: 100)',
+          zh: '最多返回结果数（默认 10，最大 100）',
         },
       },
     },
@@ -46,7 +170,7 @@ Results are returned newest-first with message role and content.`,
   isConcurrencySafe: () => true,
   isReadOnly: () => true,
   async execute(input, ctx) {
-    const { keyword, limit = 20 } = input;
+    const { keyword, limit = DEFAULT_RESULT_LIMIT } = input;
     if (!keyword) return JSON.stringify({ error: 'keyword is required' });
 
     const yeaftDir = ctx?.yeaftDir;
@@ -55,25 +179,37 @@ Results are returned newest-first with message role and content.`,
     }
 
     try {
-      const results = searchMessages(yeaftDir, keyword, limit);
+      const telemetry = {};
+      const results = searchMessages(yeaftDir, keyword, limit, { telemetry });
+      const searchTelemetry = {
+        resultCount: results.length,
+        scannedFiles: telemetry.scannedFiles || 0,
+        scannedMessages: telemetry.scannedMessages || 0,
+        scannedBytes: telemetry.scannedBytes || 0,
+      };
 
       if (results.length === 0) {
-        return JSON.stringify({
+        return serializeHistorySearchOutput({
           results: [],
           message: `No matches found for "${keyword}"`,
+          telemetry: searchTelemetry,
         });
       }
 
-      return JSON.stringify({
+      return serializeHistorySearchOutput({
         results: results.map(msg => ({
+          messageId: msg.id || null,
+          sessionId: msg.sessionId || null,
           role: msg.role,
-          content: msg.content?.slice(0, 2000) + (msg.content?.length > 2000 ? '...' : ''),
+          content: buildSnippet(msg.content, keyword),
           mode: msg.mode,
-          timestamp: msg.timestamp,
+          time: msg.time || msg.timestamp || null,
+          source: msg.historySource || null,
         })),
         totalResults: results.length,
         keyword,
-      }, null, 2);
+        telemetry: searchTelemetry,
+      });
     } catch (err) {
       return JSON.stringify({ error: `History search failed: ${err.message}` });
     }