@ai-setting/roy-agent-core 1.5.13-test → 1.5.15-test

package/dist/shared/@ai-setting/roy-agent-core-81w1963m.js

@@ -1,762 +0,0 @@
-import {
-  init_search_query_parser,
-  matchesQuery,
-  parseSearchQuery
-} from "./roy-agent-core-rvxg1wps.js";
-import {
-  SummaryAgent
-} from "./roy-agent-core-eajcvp4e.js";
-import {
-  envKeyToConfigKey
-} from "./roy-agent-core-qxhq8ven.js";
-import {
-  BaseComponent
-} from "./roy-agent-core-kkbwepqb.js";
-import {
-  MemorySessionStore,
-  SQLiteSessionStore
-} from "./roy-agent-core-d7cyjkf7.js";
-import {
-  TracedAs,
-  init_decorator
-} from "./roy-agent-core-zgypchmt.js";
-import {
-  createLogger,
-  init_logger
-} from "./roy-agent-core-44hnfb02.js";
-import {
-  __legacyDecorateClassTS
-} from "./roy-agent-core-fs0mn2jk.js";
-
-// src/env/session/session-component.ts
-init_logger();
-init_decorator();
-
-// src/env/session/session-config-registration.ts
-var SESSION_DEFAULTS = {
-  "session.defaultDirectory": "/tmp",
-  "session.defaultTitleTemplate": "Session - {date}",
-  "session.maxMessages": 100,
-  "session.compactionThreshold": 80,
-  "session.autoCompact": true,
-  "session.storage.type": "sqlite",
-  "session.storage.dbPath": undefined,
-  "session.checkpoint.enabled": false,
-  "session.contextLimit": 1e5,
-  "session.maxSessions": 100
-};
-var SESSION_CONFIG_REGISTRATION = {
-  name: "session",
-  sources: [
-    { type: "env", envPrefix: "SESSION", priority: 20, watch: false }
-  ],
-  keys: [
-    { key: "session.defaultDirectory", sources: ["env", "file"] },
-    { key: "session.defaultTitleTemplate", sources: ["env", "file"] },
-    { key: "session.maxMessages", sources: ["env", "file"] },
-    { key: "session.compactionThreshold", sources: ["env", "file"] },
-    { key: "session.autoCompact", sources: ["env", "file"] },
-    { key: "session.storage.type", sources: ["env", "file"] },
-    { key: "session.storage.dbPath", sources: ["env", "file"] },
-    { key: "session.checkpoint.enabled", sources: ["env", "file"] },
-    { key: "session.contextLimit", sources: ["env", "file"] },
-    { key: "session.maxSessions", sources: ["env", "file"] }
-  ]
-};
-
-// src/env/session/session-component.ts
-init_search_query_parser();
-import path from "path";
-var logger = createLogger("session");
-
-class SessionComponent extends BaseComponent {
-  name = "session";
-  version = "1.1.0";
-  config;
-  store;
-  activeSessionId;
-  hooksConfig = {};
-  configComponent;
-  configWatcher;
-  summaryAgent;
-  promptComponent;
-  llmComponent;
-  constructor() {
-    super();
-  }
-  async init(config) {
-    await super.init(config);
-    const options = config?.options;
-    if (!options?.configComponent) {
-      throw new Error("ConfigComponent is required for SessionComponent initialization");
-    }
-    this.configComponent = options.configComponent;
-    await this.registerConfig(options);
-    const storageConfig = this.config?.storage;
-    if (storageConfig?.type === "sqlite") {
-      this.store = new SQLiteSessionStore(storageConfig.dbPath);
-      logger.info(`[SessionComponent] Using SQLite storage: ${storageConfig.dbPath || "default path"}`);
-    } else {
-      this.store = new MemorySessionStore;
-      logger.info("[SessionComponent] Using memory storage");
-    }
-    this.setStatus("running");
-    logger.info("[SessionComponent] Initialized");
-  }
-  getDefaultSessionDbPath() {
-    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
-    return path.join(home, ".local", "share", "roy-agent", "sessions.db");
-  }
-  async registerConfig(options) {
-    const configComponent = options.configComponent;
-    if (!configComponent)
-      return;
-    const { configPath, envPrefix, config } = options;
-    const prefix = envPrefix !== undefined ? envPrefix : "SESSION";
-    configComponent.registerComponent(SESSION_CONFIG_REGISTRATION);
-    if (configPath) {
-      configComponent.registerSource({
-        type: "file",
-        relativePath: configPath,
-        optional: true,
-        watch: false
-      });
-    }
-    configComponent.registerSource({
-      type: "env",
-      envPrefix: prefix,
-      priority: 20,
-      watch: false
-    });
-    await configComponent.load("session");
-    for (const envKey of Object.keys(process.env)) {
-      const configKey = envKeyToConfigKey(envKey, prefix, "session");
-      if (!configKey)
-        continue;
-      const value = process.env[envKey];
-      if (value !== undefined) {
-        await configComponent.set(configKey, value);
-      }
-    }
-    for (const [key, value] of Object.entries(SESSION_DEFAULTS)) {
-      if (configComponent.get(key) === undefined) {
-        await configComponent.set(key, value);
-      }
-    }
-    if (configComponent.get("session.storage.dbPath") === undefined) {
-      await configComponent.set("session.storage.dbPath", this.getDefaultSessionDbPath());
-    }
-    if (config) {
-      const flatConfig = this.flattenConfig(config);
-      for (const [key, value] of Object.entries(flatConfig)) {
-        await configComponent.set(key, value);
-      }
-    }
-    this.registerConfigWatcher(configComponent);
-    this.config = this.buildConfig(configComponent);
-  }
-  buildConfig(configComponent) {
-    return {
-      defaultDirectory: configComponent.get("session.defaultDirectory"),
-      defaultTitleTemplate: configComponent.get("session.defaultTitleTemplate"),
-      maxMessages: configComponent.get("session.maxMessages"),
-      compactionThreshold: configComponent.get("session.compactionThreshold"),
-      autoCompact: configComponent.get("session.autoCompact"),
-      storage: {
-        type: configComponent.get("session.storage.type"),
-        dbPath: configComponent.get("session.storage.dbPath")
-      }
-    };
-  }
-  flattenConfig(obj, prefix = "session") {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-      const fullKey = `${prefix}.${key}`;
-      if (value && typeof value === "object" && !Array.isArray(value)) {
-        Object.assign(result, this.flattenConfig(value, fullKey));
-      } else {
-        result[fullKey] = value;
-      }
-    }
-    return result;
-  }
-  registerConfigWatcher(configComponent) {
-    if (typeof configComponent.watch !== "function") {
-      return;
-    }
-    this.configWatcher = configComponent.watch("session.*", (event) => {
-      this.onConfigChange(event);
-    });
-  }
-  onConfigChange(event) {
-    logger.info(`Session config changed: ${event.key}`, {
-      oldValue: event.oldValue,
-      newValue: event.newValue
-    });
-  }
-  async onStart() {
-    logger.info("[SessionComponent] Started");
-  }
-  async onStop() {
-    this.configWatcher?.();
-    this.configWatcher = undefined;
-    await this.store?.close();
-    this.store = undefined;
-    this.setStatus("stopped");
-    logger.info("[SessionComponent] Stopped");
-  }
-  async create(options = {}) {
-    await this.executeBeforeHooks("create", { options });
-    const title = options.title ?? this.generateTitle();
-    const session = await this.store.create({
-      ...options,
-      title
-    });
-    logger.info(`[SessionComponent] Created session: ${session.id}`, { title });
-    await this.executeAfterHooks("create", { session, options });
-    return session;
-  }
-  async get(id) {
-    await this.executeBeforeHooks("session.get", { id });
-    const session = await this.store?.get(id);
-    await this.executeAfterHooks("session.get", { session });
-    return session;
-  }
-  async getSession(id) {
-    const session = await this.get(id);
-    if (!session) {
-      return null;
-    }
-    const messages = await this.getMessages(id);
-    return {
-      sessionId: session.id,
-      title: session.title || "Untitled",
-      messages: messages.map((m) => ({
-        role: m.role,
-        content: m.content,
-        timestamp: m.timestamp
-      }))
-    };
-  }
-  async searchSessions(query, options) {
-    const limit = options?.limit ?? 20;
-    if (options?.session_id) {
-      const session = await this.get(options.session_id);
-      if (session) {
-        const messages = await this.getMessages(options.session_id);
-        const lastMessage = messages[messages.length - 1];
-        return [{
-          sessionId: session.id,
-          title: session.title || "Untitled",
-          preview: lastMessage?.content?.substring(0, 200) || "",
-          timestamp: session.updatedAt || session.createdAt
-        }];
-      }
-      return [];
-    }
-    const sessions = await this.list({ limit });
-    const results = [];
-    for (const session of sessions) {
-      if (results.length >= limit)
-        break;
-      const messages = await this.getMessages(session.id);
-      const lastMessage = messages[messages.length - 1];
-      const preview = lastMessage?.content?.substring(0, 200) || "";
-      if (query) {
-        const lowerQuery = query.toLowerCase();
-        const titleMatch = (session.title || "").toLowerCase().includes(lowerQuery);
-        const previewMatch = preview.toLowerCase().includes(lowerQuery);
-        if (!titleMatch && !previewMatch) {
-          continue;
-        }
-      }
-      results.push({
-        sessionId: session.id,
-        title: session.title || "Untitled",
-        preview,
-        timestamp: session.updatedAt || session.createdAt
-      });
-    }
-    return results;
-  }
-  async list(options) {
-    await this.executeBeforeHooks("session.list", { options });
-    const sessions = await this.store?.list(options) ?? [];
-    await this.executeAfterHooks("session.list", { sessions });
-    return sessions;
-  }
-  async getCount() {
-    return await this.store?.getCount() ?? 0;
-  }
-  async update(id, updates) {
-    await this.executeBeforeHooks("session.update", { id, updates });
-    const success = await this.store?.update(id, updates);
-    if (success) {
-      logger.info(`[SessionComponent] Updated session: ${id}`, { updates });
-      await this.executeAfterHooks("session.update", { id, updates });
-    }
-    return success ?? false;
-  }
-  async delete(id) {
-    await this.executeBeforeHooks("session.delete", { id });
-    const success = await this.store?.delete(id);
-    if (success) {
-      if (this.activeSessionId === id) {
-        this.activeSessionId = undefined;
-      }
-      logger.info(`[SessionComponent] Deleted session: ${id}`);
-      await this.executeAfterHooks("session.delete", { id });
-    }
-    return success ?? false;
-  }
-  getActiveSession() {
-    if (!this.activeSessionId)
-      return;
-    return;
-  }
-  getActiveSessionId() {
-    return this.activeSessionId;
-  }
-  async setActiveSession(id) {
-    const session = await this.store?.get(id);
-    if (!session)
-      return false;
-    this.activeSessionId = id;
-    logger.info(`[SessionComponent] Active session set: ${id}`);
-    return true;
-  }
-  async addMessage(sessionId, message) {
-    const contentPreview = typeof message.content === "string" ? message.content.substring(0, 100) : JSON.stringify(message.content).substring(0, 100);
-    logger.info(`[SessionComponent.addMessage] sessionId=${sessionId}, role=${message.role}, content="${contentPreview}"`);
-    try {
-      const messageId = await this.store?.addMessage(sessionId, message);
-      logger.info(`[SessionComponent.addMessage] Success: messageId=${messageId}`);
-      return messageId;
-    } catch (error) {
-      logger.error(`[SessionComponent] Failed to add message: ${error}`);
-      return;
-    }
-  }
-  async getMessages(sessionId, options) {
-    const messages = await this.store?.getMessages(sessionId, options?.offset, options?.limit);
-    return messages ?? [];
-  }
-  async getMessageCount(sessionId, includeArchived) {
-    return this.store?.getMessageCount(sessionId, includeArchived) ?? 0;
-  }
-  async getMessageIndexes(sessionId, role) {
-    return this.store?.getMessageIndexes(sessionId, role) ?? [];
-  }
-  async executeBeforeHooks(operation, context) {
-    const hookKey = `before.session.${operation}`;
-    const hooks = this.hooksConfig[hookKey] ?? [];
-    const hookContext = context;
-    for (const hook of hooks) {
-      if (hook.before) {
-        await hook.before(hookContext);
-      }
-    }
-    const options = context.options;
-    if (options?.hooks) {
-      const hookArray = options.hooks[hookKey] ?? [];
-      for (const hook of hookArray) {
-        if (hook.before) {
-          await hook.before(hookContext);
-        }
-      }
-    }
-  }
-  async executeAfterHooks(operation, context) {
-    const hookKey = `after.session.${operation}`;
-    const hooks = this.hooksConfig[hookKey] ?? [];
-    const hookContext = context;
-    for (const hook of hooks) {
-      if (hook.after) {
-        await hook.after(hookContext);
-      }
-    }
-    const options = context.options;
-    if (options?.hooks) {
-      const hookArray = options.hooks[hookKey] ?? [];
-      for (const hook of hookArray) {
-        if (hook.after) {
-          await hook.after(hookContext);
-        }
-      }
-    }
-  }
-  generateTitle() {
-    const template = this.config?.defaultTitleTemplate ?? "Session - {date}";
-    const date = new Date().toISOString().replace("T", " ").substring(0, 19);
-    return template.replace("{date}", date);
-  }
-  setSummaryComponents(promptComponent, llmComponent) {
-    this.promptComponent = promptComponent;
-    this.llmComponent = llmComponent;
-    this.summaryAgent = new SummaryAgent(promptComponent, llmComponent);
-  }
-  ensureSummaryAgent() {
-    if (!this.summaryAgent) {
-      if (!this.promptComponent || !this.llmComponent) {
-        throw new Error("SummaryAgent components not initialized. Call setSummaryComponents() first.");
-      }
-      this.summaryAgent = new SummaryAgent(this.promptComponent, this.llmComponent);
-    }
-  }
-  async generateCompactHint(sessionId) {
-    const session = await this.get(sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-    const latestCheckpoint = this.getLatestCheckpoint(session);
-    const startIndex = latestCheckpoint?.messageIndex ?? 0;
-    const MAX_SAFE_MESSAGES = Number.MAX_SAFE_INTEGER;
-    const messages = await this.store.getMessages(sessionId, startIndex, MAX_SAFE_MESSAGES, { includeArchived: false });
-    if (messages.length < 3) {
-      logger.warn("[SessionComponent] Not enough messages for hint generation");
-      return "";
-    }
-    this.ensureSummaryAgent();
-    const result = await this.summaryAgent.generateCompactHint({
-      messages: messages.map((m) => ({ role: m.role, content: m.content })),
-      sessionContext: {}
-    });
-    logger.info("[SessionComponent] Compact hint generated", {
-      sessionId,
-      hintLength: result.hint.length
-    });
-    return result.hint;
-  }
-  async compact(sessionId, options) {
-    const session = await this.get(sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-    const latestCheckpoint = this.getLatestCheckpoint(session);
-    const startIndex = latestCheckpoint?.messageIndex ?? 0;
-    const MAX_SAFE_MESSAGES = Number.MAX_SAFE_INTEGER;
-    const messages = await this.store.getMessages(sessionId, startIndex, MAX_SAFE_MESSAGES, { includeArchived: false });
-    if (messages.length < 3) {
-      throw new Error("Not enough messages to compact (minimum 3 required)");
-    }
-    const recentMessages = this.extractRecentMessages(messages, 2);
-    this.ensureSummaryAgent();
-    await this.executeBeforeHooks("compact", { session, options });
-    const summaryResult = await this.summaryAgent.run({
-      messages: messages.map((m) => ({ role: m.role, content: m.content })),
-      userContext: options?.summary,
-      outputFormat: "json",
-      scenarioHint: options?.scenarioHint
-    });
-    const checkpointId = `cp_${Date.now().toString(36)}_${Math.random().toString(36).substring(2, 8)}`;
-    const checkpoint = {
-      id: checkpointId,
-      messageIndex: startIndex,
-      title: summaryResult.title,
-      summary: [
-        `Process: ${summaryResult.processKeyPoints.join("; ")}`,
-        `State: ${summaryResult.currentState}`
-      ].join(`
-`),
-      processKeyPoints: summaryResult.processKeyPoints,
-      currentState: summaryResult.currentState,
-      nextSteps: summaryResult.nextSteps,
-      userIntents: summaryResult.userIntents,
-      messageCountBefore: messages.length,
-      createdAt: Date.now(),
-      type: "compact",
-      recentMessages
-    };
-    await this.store.saveCheckpoint(sessionId, checkpoint);
-    await this.store.archiveMessages(sessionId, checkpointId, messages.length);
-    const checkpointMessage = this.createCheckpointMessage(checkpoint);
-    await this.store.addMessage(sessionId, checkpointMessage);
-    const updatedSession = await this.get(sessionId);
-    const remainingMessageCount = updatedSession?.messageCount ?? 0;
-    const checkpointCount = updatedSession?.metadata?.checkpoints?.checkpoints?.length ?? 0;
-    logger.info(`[SessionComponent] Compacted session: ${sessionId}`, {
-      checkpointId,
-      archivedCount: messages.length,
-      remainingCount: remainingMessageCount,
-      hasScenarioHint: !!options?.scenarioHint,
-      recentMessagesCount: recentMessages.length
-    });
-    await this.executeAfterHooks("compact", { session, checkpoint, options });
-    return {
-      checkpoint,
-      deletedMessageCount: messages.length,
-      remainingMessageCount,
-      checkpointCount
-    };
-  }
-  extractRecentMessages(messages, turnCount = 2) {
-    const recentMessages = [];
-    let turnsExtracted = 0;
-    let i = messages.length - 1;
-    while (i >= 0 && turnsExtracted < turnCount) {
-      const msg = messages[i];
-      if (msg.metadata?.isCheckpoint) {
-        i--;
-        continue;
-      }
-      const hasToolParts = msg.parts?.some((p) => p.type === "tool-call" || p.type === "tool-result");
-      if (msg.role === "assistant" && !hasToolParts && msg.content.trim()) {
-        recentMessages.unshift({
-          role: "assistant",
-          content: msg.content
-        });
-        let j = i - 1;
-        while (j >= 0) {
-          const prevMsg = messages[j];
-          if (prevMsg.metadata?.isCheckpoint) {
-            j--;
-            continue;
-          }
-          if (prevMsg.role === "user") {
-            recentMessages.unshift({
-              role: "user",
-              content: prevMsg.content
-            });
-            turnsExtracted++;
-            break;
-          }
-          j--;
-        }
-        i = j;
-      } else {
-        i--;
-      }
-    }
-    logger.debug("[SessionComponent] Extracted recent messages", {
-      turnCount,
-      messagesExtracted: recentMessages.length
-    });
-    return recentMessages;
-  }
-  async previewCompact(sessionId) {
-    const session = await this.get(sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-    const latestCheckpoint = this.getLatestCheckpoint(session);
-    const startIndex = latestCheckpoint?.messageIndex ?? 0;
-    const MAX_SAFE_MESSAGES = Number.MAX_SAFE_INTEGER;
-    const messages = await this.store.getMessages(sessionId, startIndex, MAX_SAFE_MESSAGES, { includeArchived: false });
-    const estimatedTokens = messages.reduce((sum, m) => sum + m.content.length * 0.25, 0);
-    return {
-      messageCountToCompact: messages.length,
-      estimatedCheckpointTokens: Math.round(estimatedTokens * 0.1),
-      wouldTrigger: messages.length >= (this.config?.maxMessages ?? 50)
-    };
-  }
-  async getCheckpoints(sessionId) {
-    return await this.store.getCheckpoints(sessionId);
-  }
-  async getCheckpoint(sessionId, checkpointId) {
-    return await this.store.getCheckpoint(sessionId, checkpointId);
-  }
-  async deleteCheckpoint(sessionId, checkpointId) {
-    await this.executeBeforeHooks("deleteCheckpoint", { sessionId, checkpointId });
-    const success = await this.store.deleteCheckpoint(sessionId, checkpointId);
-    if (success) {
-      logger.info(`[SessionComponent] Deleted checkpoint: ${checkpointId}`);
-      await this.executeAfterHooks("deleteCheckpoint", { sessionId, checkpointId });
-    }
-    return success;
-  }
-  async getContext(sessionId, options) {
-    const session = await this.get(sessionId);
-    if (!session) {
-      throw new Error(`Session not found`);
-    }
-    let contextMessages = [];
-    let startCheckpoint;
-    if (options?.fullHistory) {
-      const MAX_SAFE_MESSAGES = Number.MAX_SAFE_INTEGER;
-      contextMessages = await this.store.getMessages(sessionId, 0, MAX_SAFE_MESSAGES, {
-        includeArchived: true
-      });
-    } else {
-      const latestCheckpointId = session.metadata?.checkpoints?.latestCheckpointId;
-      if (latestCheckpointId) {
-        startCheckpoint = await this.store.getCheckpoint(sessionId, latestCheckpointId);
-        if (startCheckpoint) {
-          const MAX_SAFE_MESSAGES = Number.MAX_SAFE_INTEGER;
-          contextMessages = await this.store.getMessages(sessionId, startCheckpoint.messageIndex, MAX_SAFE_MESSAGES, { includeArchived: false });
-        }
-      }
-      if (contextMessages.length === 0) {
-        const MAX_SAFE_MESSAGES = Number.MAX_SAFE_INTEGER;
-        contextMessages = await this.store.getMessages(sessionId, 0, MAX_SAFE_MESSAGES, {
-          includeArchived: false
-        });
-      }
-    }
-    if (options?.minUserMessages && options.minUserMessages > 0) {
-      const userIndexes = [];
-      for (let i = 0;i < contextMessages.length; i++) {
-        if (contextMessages[i].role === "user") {
-          userIndexes.push(i);
-        }
-      }
-      if (userIndexes.length > options.minUserMessages) {
-        const targetIndex = userIndexes[userIndexes.length - options.minUserMessages];
-        contextMessages = contextMessages.slice(targetIndex);
-      }
-    }
-    if (options?.messageLimit) {
-      contextMessages = contextMessages.slice(-options.messageLimit);
-    }
-    const checkpoints = contextMessages.filter((m) => m.metadata?.isCheckpoint).map((m) => m.metadata.checkpointMeta);
-    const estimatedTokens = contextMessages.reduce((sum, m) => sum + m.content.length * 0.25, 0);
-    return {
-      session,
-      checkpoints,
-      startCheckpoint: startCheckpoint ?? checkpoints[checkpoints.length - 1],
-      messages: contextMessages,
-      totalMessageCount: contextMessages.length,
-      activeMessageCount: contextMessages.filter((m) => !m.isArchived).length,
-      archivedMessageCount: contextMessages.filter((m) => m.isArchived).length,
-      estimatedTokens: Math.round(estimatedTokens)
-    };
-  }
-  async shouldCompact(sessionId) {
-    const session = await this.get(sessionId);
-    if (!session)
-      return false;
-    const preview = await this.previewCompact(sessionId);
-    return preview.wouldTrigger;
-  }
-  async searchMessages(options) {
-    const {
-      query,
-      sessionId,
-      limit = 10,
-      maxResults = 100,
-      beforeTime,
-      afterTime,
-      includeArchived = false,
-      includeContext = false,
-      contextLines = 2
-    } = options;
-    if (!this.store) {
-      return [];
-    }
-    let sessions;
-    if (sessionId) {
-      const session = await this.get(sessionId);
-      sessions = session ? [session] : [];
-    } else {
-      sessions = await this.list({ limit: 1000 });
-    }
-    const results = [];
-    let totalMatches = 0;
-    for (const session of sessions) {
-      if (beforeTime && session.updatedAt > beforeTime)
-        continue;
-      if (afterTime && session.updatedAt < afterTime)
-        continue;
-      const messages = await this.store.getMessages(session.id, 0, 1000, { includeArchived });
-      const queryTerms = parseSearchQuery(query);
-      const matches = [];
-      for (const msg of messages) {
-        if (beforeTime && msg.timestamp > beforeTime)
-          continue;
-        if (afterTime && msg.timestamp < afterTime)
-          continue;
-        if (matchesQuery(msg.content, queryTerms)) {
-          const match = {
-            messageId: msg.id,
-            sessionId: session.id,
-            role: msg.role,
-            content: msg.content,
-            timestamp: msg.timestamp
-          };
-          if (includeContext) {
-            const msgIndex = messages.indexOf(msg);
-            const beforeMsgs = messages.slice(Math.max(0, msgIndex - contextLines), msgIndex);
-            const afterMsgs = messages.slice(msgIndex + 1, msgIndex + 1 + contextLines);
-            match.contextBefore = beforeMsgs.map((m) => m.content).join(`
-`);
-            match.contextAfter = afterMsgs.map((m) => m.content).join(`
-`);
-          }
-          matches.push(match);
-          if (matches.length >= limit)
-            break;
-        }
-      }
-      if (matches.length > 0) {
-        results.push({
-          sessionId: session.id,
-          sessionTitle: session.title,
-          sessionDirectory: session.directory,
-          updatedAt: session.updatedAt,
-          messageCount: session.messageCount,
-          matches
-        });
-        totalMatches += matches.length;
-        if (totalMatches >= maxResults)
-          break;
-      }
-    }
-    return results;
-  }
-  getLatestCheckpoint(session) {
-    const latestId = session.metadata?.checkpoints?.latestCheckpointId;
-    if (!latestId)
-      return;
-    return session.metadata?.checkpointDetails?.[latestId];
-  }
-  createCheckpointMessage(checkpoint) {
-    const lines = [
-      `# Checkpoint: ${checkpoint.title}`,
-      "",
-      "## Process Key Points",
-      ...checkpoint.processKeyPoints.map((p, i) => `${i + 1}. ${p}`),
-      "",
-      "## Current State",
-      checkpoint.currentState,
-      ""
-    ];
-    if (checkpoint.nextSteps?.length) {
-      lines.push("## Next Steps");
-      checkpoint.nextSteps.forEach((s, i) => lines.push(`${i + 1}. ${s}`));
-      lines.push("");
-    }
-    lines.push("## Messages Compacted");
-    lines.push(`${checkpoint.messageCountBefore} messages compacted at ${new Date(checkpoint.createdAt).toISOString()}`);
-    const content = lines.join(`
-`);
-    return {
-      role: "user",
-      content,
-      parts: [{
-        type: "checkpoint",
-        checkpointId: checkpoint.id,
-        content,
-        title: checkpoint.title,
-        processKeyPoints: checkpoint.processKeyPoints,
-        currentState: checkpoint.currentState,
-        nextSteps: checkpoint.nextSteps,
-        messageCountBefore: checkpoint.messageCountBefore,
-        createdAt: checkpoint.createdAt
-      }],
-      metadata: {
-        isCheckpoint: true,
-        checkpointId: checkpoint.id,
-        checkpointMeta: checkpoint
-      }
-    };
-  }
-}
-__legacyDecorateClassTS([
-  TracedAs("session.generateCompactHint")
-], SessionComponent.prototype, "generateCompactHint", null);
-__legacyDecorateClassTS([
-  TracedAs("session.compact", { recordParams: true, recordResult: true })
-], SessionComponent.prototype, "compact", null);
-__legacyDecorateClassTS([
-  TracedAs("session.extractRecentMessages")
-], SessionComponent.prototype, "extractRecentMessages", null);
-export { SessionComponent };