@dexto/core 1.1.4 → 1.1.6

package/dist/search/search-service.cjs

@@ -0,0 +1,245 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var search_service_exports = {};
+__export(search_service_exports, {
+  SearchService: () => SearchService
+});
+module.exports = __toCommonJS(search_service_exports);
+var import_logger = require("../logger/index.js");
+class SearchService {
+  constructor(database) {
+    this.database = database;
+  }
+  /**
+   * Search for messages across all sessions or within a specific session
+   */
+  async searchMessages(query, options = {}) {
+    const { sessionId, role, limit = 20, offset = 0 } = options;
+    if (!query.trim()) {
+      return {
+        results: [],
+        total: 0,
+        hasMore: false,
+        query,
+        options
+      };
+    }
+    try {
+      import_logger.logger.debug(`Searching messages for query: "${query}"`, {
+        sessionId,
+        role,
+        limit,
+        offset
+      });
+      const allResults = [];
+      const sessionIds = sessionId ? [sessionId] : await this.getSessionIds();
+      for (const sId of sessionIds) {
+        const sessionResults = await this.searchInSession(query, sId, role);
+        allResults.push(...sessionResults);
+      }
+      const sortedResults = this.sortResults(allResults, query);
+      const total = sortedResults.length;
+      const paginatedResults = sortedResults.slice(offset, offset + limit);
+      const hasMore = offset + limit < total;
+      return {
+        results: paginatedResults,
+        total,
+        hasMore,
+        query,
+        options
+      };
+    } catch (error) {
+      import_logger.logger.error(
+        `Error searching messages: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return {
+        results: [],
+        total: 0,
+        hasMore: false,
+        query,
+        options
+      };
+    }
+  }
+  /**
+   * Search for sessions that contain the query
+   */
+  async searchSessions(query) {
+    if (!query.trim()) {
+      return {
+        results: [],
+        total: 0,
+        hasMore: false,
+        query
+      };
+    }
+    try {
+      import_logger.logger.debug(`Searching sessions for query: "${query}"`);
+      const sessionResults = [];
+      const sessionIds = await this.getSessionIds();
+      for (const sessionId of sessionIds) {
+        const messageResults = await this.searchInSession(query, sessionId);
+        if (messageResults.length > 0) {
+          const sessionMetadata = await this.getSessionMetadata(sessionId);
+          if (sessionMetadata) {
+            const firstMatch = messageResults[0];
+            if (firstMatch) {
+              sessionResults.push({
+                sessionId,
+                matchCount: messageResults.length,
+                firstMatch,
+                metadata: sessionMetadata
+              });
+            }
+          }
+        }
+      }
+      const sortedResults = sessionResults.sort((a, b) => {
+        if (a.matchCount !== b.matchCount) {
+          return b.matchCount - a.matchCount;
+        }
+        return b.metadata.lastActivity - a.metadata.lastActivity;
+      });
+      return {
+        results: sortedResults,
+        total: sortedResults.length,
+        hasMore: false,
+        query
+      };
+    } catch (error) {
+      import_logger.logger.error(
+        `Error searching sessions: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return {
+        results: [],
+        total: 0,
+        hasMore: false,
+        query
+      };
+    }
+  }
+  /**
+   * Search for messages within a specific session
+   */
+  async searchInSession(query, sessionId, role) {
+    const messagesKey = `messages:${sessionId}`;
+    const MAX_MESSAGES_PER_SEARCH = 1e4;
+    const messages = await this.database.getRange(
+      messagesKey,
+      0,
+      MAX_MESSAGES_PER_SEARCH
+    );
+    const results = [];
+    const lowerQuery = query.toLowerCase();
+    for (let i = 0; i < messages.length; i++) {
+      const message = messages[i];
+      if (!message) {
+        continue;
+      }
+      if (role && message.role !== role) {
+        continue;
+      }
+      const searchableText = this.extractSearchableText(message);
+      if (!searchableText) {
+        continue;
+      }
+      const lowerText = searchableText.toLowerCase();
+      const matchIndex = lowerText.indexOf(lowerQuery);
+      if (matchIndex !== -1) {
+        const matchedText = searchableText.substring(matchIndex, matchIndex + query.length);
+        const context = this.getContext(searchableText, matchIndex, query.length);
+        results.push({
+          sessionId,
+          message,
+          matchedText,
+          context,
+          messageIndex: i
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * Extract searchable text from a message
+   */
+  extractSearchableText(message) {
+    if (!message.content) {
+      return null;
+    }
+    if (typeof message.content === "string") {
+      return message.content;
+    }
+    if (Array.isArray(message.content)) {
+      return message.content.filter((part) => part.type === "text").map((part) => "text" in part ? part.text : "").join(" ");
+    }
+    return null;
+  }
+  /**
+   * Get context around a match for preview
+   */
+  getContext(text, matchIndex, matchLength, contextLength = 50) {
+    const start = Math.max(0, matchIndex - contextLength);
+    const end = Math.min(text.length, matchIndex + matchLength + contextLength);
+    let context = text.substring(start, end);
+    if (start > 0) {
+      context = "..." + context;
+    }
+    if (end < text.length) {
+      context = context + "...";
+    }
+    return context;
+  }
+  /**
+   * Sort search results by relevance
+   */
+  sortResults(results, query) {
+    const lowerQuery = query.toLowerCase();
+    return results.sort((a, b) => {
+      const aText = this.extractSearchableText(a.message)?.toLowerCase() || "";
+      const bText = this.extractSearchableText(b.message)?.toLowerCase() || "";
+      const aExactMatch = aText.includes(` ${lowerQuery} `) || aText.startsWith(lowerQuery) || aText.endsWith(lowerQuery);
+      const bExactMatch = bText.includes(` ${lowerQuery} `) || bText.startsWith(lowerQuery) || bText.endsWith(lowerQuery);
+      if (aExactMatch && !bExactMatch) return -1;
+      if (!aExactMatch && bExactMatch) return 1;
+      return b.messageIndex - a.messageIndex;
+    });
+  }
+  /**
+   * Get all session IDs
+   */
+  async getSessionIds() {
+    const sessionKeys = await this.database.list("session:");
+    return sessionKeys.map((key) => key.replace("session:", ""));
+  }
+  /**
+   * Get session metadata
+   */
+  async getSessionMetadata(sessionId) {
+    const sessionKey = `session:${sessionId}`;
+    const sessionData = await this.database.get(sessionKey);
+    if (!sessionData) {
+      throw new Error(`Session metadata not found: ${sessionId}`);
+    }
+    return sessionData;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SearchService
+});

package/dist/search/search-service.d.cts

@@ -0,0 +1,47 @@
+import { DatabaseBackend } from '../storage/backend/database-backend.cjs';
+import { SearchOptions, SearchResponse, SessionSearchResponse } from './types.cjs';
+import '../context/types.cjs';
+import '../llm/types.cjs';
+
+/**
+ * Service for searching through conversation history
+ * TODO: remove duplicate stuff related to session manager instead of directly using DB
+ */
+declare class SearchService {
+    private database;
+    constructor(database: DatabaseBackend);
+    /**
+     * Search for messages across all sessions or within a specific session
+     */
+    searchMessages(query: string, options?: SearchOptions): Promise<SearchResponse>;
+    /**
+     * Search for sessions that contain the query
+     */
+    searchSessions(query: string): Promise<SessionSearchResponse>;
+    /**
+     * Search for messages within a specific session
+     */
+    private searchInSession;
+    /**
+     * Extract searchable text from a message
+     */
+    private extractSearchableText;
+    /**
+     * Get context around a match for preview
+     */
+    private getContext;
+    /**
+     * Sort search results by relevance
+     */
+    private sortResults;
+    /**
+     * Get all session IDs
+     */
+    private getSessionIds;
+    /**
+     * Get session metadata
+     */
+    private getSessionMetadata;
+}
+
+export { SearchService };

package/dist/search/search-service.d.ts

@@ -0,0 +1,47 @@
+import { DatabaseBackend } from '../storage/backend/database-backend.js';
+import { SearchOptions, SearchResponse, SessionSearchResponse } from './types.js';
+import '../context/types.js';
+import '../llm/types.js';
+
+/**
+ * Service for searching through conversation history
+ * TODO: remove duplicate stuff related to session manager instead of directly using DB
+ */
+declare class SearchService {
+    private database;
+    constructor(database: DatabaseBackend);
+    /**
+     * Search for messages across all sessions or within a specific session
+     */
+    searchMessages(query: string, options?: SearchOptions): Promise<SearchResponse>;
+    /**
+     * Search for sessions that contain the query
+     */
+    searchSessions(query: string): Promise<SessionSearchResponse>;
+    /**
+     * Search for messages within a specific session
+     */
+    private searchInSession;
+    /**
+     * Extract searchable text from a message
+     */
+    private extractSearchableText;
+    /**
+     * Get context around a match for preview
+     */
+    private getContext;
+    /**
+     * Sort search results by relevance
+     */
+    private sortResults;
+    /**
+     * Get all session IDs
+     */
+    private getSessionIds;
+    /**
+     * Get session metadata
+     */
+    private getSessionMetadata;
+}
+
+export { SearchService };

package/dist/search/search-service.js

@@ -0,0 +1,221 @@
+import { logger } from "../logger/index.js";
+class SearchService {
+  constructor(database) {
+    this.database = database;
+  }
+  /**
+   * Search for messages across all sessions or within a specific session
+   */
+  async searchMessages(query, options = {}) {
+    const { sessionId, role, limit = 20, offset = 0 } = options;
+    if (!query.trim()) {
+      return {
+        results: [],
+        total: 0,
+        hasMore: false,
+        query,
+        options
+      };
+    }
+    try {
+      logger.debug(`Searching messages for query: "${query}"`, {
+        sessionId,
+        role,
+        limit,
+        offset
+      });
+      const allResults = [];
+      const sessionIds = sessionId ? [sessionId] : await this.getSessionIds();
+      for (const sId of sessionIds) {
+        const sessionResults = await this.searchInSession(query, sId, role);
+        allResults.push(...sessionResults);
+      }
+      const sortedResults = this.sortResults(allResults, query);
+      const total = sortedResults.length;
+      const paginatedResults = sortedResults.slice(offset, offset + limit);
+      const hasMore = offset + limit < total;
+      return {
+        results: paginatedResults,
+        total,
+        hasMore,
+        query,
+        options
+      };
+    } catch (error) {
+      logger.error(
+        `Error searching messages: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return {
+        results: [],
+        total: 0,
+        hasMore: false,
+        query,
+        options
+      };
+    }
+  }
+  /**
+   * Search for sessions that contain the query
+   */
+  async searchSessions(query) {
+    if (!query.trim()) {
+      return {
+        results: [],
+        total: 0,
+        hasMore: false,
+        query
+      };
+    }
+    try {
+      logger.debug(`Searching sessions for query: "${query}"`);
+      const sessionResults = [];
+      const sessionIds = await this.getSessionIds();
+      for (const sessionId of sessionIds) {
+        const messageResults = await this.searchInSession(query, sessionId);
+        if (messageResults.length > 0) {
+          const sessionMetadata = await this.getSessionMetadata(sessionId);
+          if (sessionMetadata) {
+            const firstMatch = messageResults[0];
+            if (firstMatch) {
+              sessionResults.push({
+                sessionId,
+                matchCount: messageResults.length,
+                firstMatch,
+                metadata: sessionMetadata
+              });
+            }
+          }
+        }
+      }
+      const sortedResults = sessionResults.sort((a, b) => {
+        if (a.matchCount !== b.matchCount) {
+          return b.matchCount - a.matchCount;
+        }
+        return b.metadata.lastActivity - a.metadata.lastActivity;
+      });
+      return {
+        results: sortedResults,
+        total: sortedResults.length,
+        hasMore: false,
+        query
+      };
+    } catch (error) {
+      logger.error(
+        `Error searching sessions: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return {
+        results: [],
+        total: 0,
+        hasMore: false,
+        query
+      };
+    }
+  }
+  /**
+   * Search for messages within a specific session
+   */
+  async searchInSession(query, sessionId, role) {
+    const messagesKey = `messages:${sessionId}`;
+    const MAX_MESSAGES_PER_SEARCH = 1e4;
+    const messages = await this.database.getRange(
+      messagesKey,
+      0,
+      MAX_MESSAGES_PER_SEARCH
+    );
+    const results = [];
+    const lowerQuery = query.toLowerCase();
+    for (let i = 0; i < messages.length; i++) {
+      const message = messages[i];
+      if (!message) {
+        continue;
+      }
+      if (role && message.role !== role) {
+        continue;
+      }
+      const searchableText = this.extractSearchableText(message);
+      if (!searchableText) {
+        continue;
+      }
+      const lowerText = searchableText.toLowerCase();
+      const matchIndex = lowerText.indexOf(lowerQuery);
+      if (matchIndex !== -1) {
+        const matchedText = searchableText.substring(matchIndex, matchIndex + query.length);
+        const context = this.getContext(searchableText, matchIndex, query.length);
+        results.push({
+          sessionId,
+          message,
+          matchedText,
+          context,
+          messageIndex: i
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * Extract searchable text from a message
+   */
+  extractSearchableText(message) {
+    if (!message.content) {
+      return null;
+    }
+    if (typeof message.content === "string") {
+      return message.content;
+    }
+    if (Array.isArray(message.content)) {
+      return message.content.filter((part) => part.type === "text").map((part) => "text" in part ? part.text : "").join(" ");
+    }
+    return null;
+  }
+  /**
+   * Get context around a match for preview
+   */
+  getContext(text, matchIndex, matchLength, contextLength = 50) {
+    const start = Math.max(0, matchIndex - contextLength);
+    const end = Math.min(text.length, matchIndex + matchLength + contextLength);
+    let context = text.substring(start, end);
+    if (start > 0) {
+      context = "..." + context;
+    }
+    if (end < text.length) {
+      context = context + "...";
+    }
+    return context;
+  }
+  /**
+   * Sort search results by relevance
+   */
+  sortResults(results, query) {
+    const lowerQuery = query.toLowerCase();
+    return results.sort((a, b) => {
+      const aText = this.extractSearchableText(a.message)?.toLowerCase() || "";
+      const bText = this.extractSearchableText(b.message)?.toLowerCase() || "";
+      const aExactMatch = aText.includes(` ${lowerQuery} `) || aText.startsWith(lowerQuery) || aText.endsWith(lowerQuery);
+      const bExactMatch = bText.includes(` ${lowerQuery} `) || bText.startsWith(lowerQuery) || bText.endsWith(lowerQuery);
+      if (aExactMatch && !bExactMatch) return -1;
+      if (!aExactMatch && bExactMatch) return 1;
+      return b.messageIndex - a.messageIndex;
+    });
+  }
+  /**
+   * Get all session IDs
+   */
+  async getSessionIds() {
+    const sessionKeys = await this.database.list("session:");
+    return sessionKeys.map((key) => key.replace("session:", ""));
+  }
+  /**
+   * Get session metadata
+   */
+  async getSessionMetadata(sessionId) {
+    const sessionKey = `session:${sessionId}`;
+    const sessionData = await this.database.get(sessionKey);
+    if (!sessionData) {
+      throw new Error(`Session metadata not found: ${sessionId}`);
+    }
+    return sessionData;
+  }
+}
+export {
+  SearchService
+};

package/dist/search/types.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/search/types.d.cts

@@ -0,0 +1,78 @@
+import { InternalMessage } from '../context/types.cjs';
+import '../llm/types.cjs';
+
+/**
+ * Options for searching messages
+ */
+interface SearchOptions {
+    /** Limit search to a specific session */
+    sessionId?: string;
+    /** Filter by message role */
+    role?: 'user' | 'assistant' | 'system' | 'tool';
+    /** Maximum number of results to return */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+}
+/**
+ * Result of a message search
+ */
+interface SearchResult {
+    /** Session ID where the message was found */
+    sessionId: string;
+    /** The message that matched the search */
+    message: InternalMessage;
+    /** The specific text that matched the search query */
+    matchedText: string;
+    /** Context around the match for preview */
+    context: string;
+    /** Index of the message within the session */
+    messageIndex: number;
+}
+/**
+ * Result of a session search
+ */
+interface SessionSearchResult {
+    /** Session ID */
+    sessionId: string;
+    /** Number of messages that matched in this session */
+    matchCount: number;
+    /** Preview of the first matching message */
+    firstMatch: SearchResult;
+    /** Session metadata */
+    metadata: {
+        createdAt: number;
+        lastActivity: number;
+        messageCount: number;
+    };
+}
+/**
+ * Response format for search API
+ */
+interface SearchResponse {
+    /** Array of search results */
+    results: SearchResult[];
+    /** Total number of results available */
+    total: number;
+    /** Whether there are more results beyond the current page */
+    hasMore: boolean;
+    /** Query that was searched */
+    query: string;
+    /** Options used for the search */
+    options: SearchOptions;
+}
+/**
+ * Response format for session search API
+ */
+interface SessionSearchResponse {
+    /** Array of session search results */
+    results: SessionSearchResult[];
+    /** Total number of sessions with matches */
+    total: number;
+    /** Whether there are more results beyond the current page */
+    hasMore: boolean;
+    /** Query that was searched */
+    query: string;
+}
+
+export type { SearchOptions, SearchResponse, SearchResult, SessionSearchResponse, SessionSearchResult };