@selesai/code 0.12.0 → 0.13.1

package/dist/extensions/pi-hermes-memory/src/store/session-parser.ts

@@ -0,0 +1,213 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Parsed session data from a JSONL file.
+ */
+export interface ParsedSession {
+  id: string;
+  project: string;
+  cwd: string;
+  startedAt: string;
+  endedAt: string | null;
+  messages: ParsedMessage[];
+}
+
+/**
+ * A single parsed message from a session.
+ */
+export interface ParsedMessage {
+  id: string;
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+  timestamp: string;
+  toolCalls?: string[];
+}
+
+/**
+ * Raw JSONL entry types.
+ */
+interface JsonlEntry {
+  type: string;
+  id?: string;
+  parentId?: string | null;
+  timestamp?: string;
+  cwd?: string;
+  message?: {
+    role?: string;
+    content?: unknown;
+    timestamp?: number;
+  };
+  customType?: string;
+  [key: string]: unknown;
+}
+
+/**
+ * Extract text content from a message's content array.
+ */
+function extractTextContent(content: unknown): string {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+
+  const parts: string[] = [];
+  for (const block of content) {
+    if (!block || typeof block !== 'object') continue;
+    const b = block as Record<string, unknown>;
+
+    switch (b.type) {
+      case 'text':
+        if (typeof b.text === 'string') parts.push(b.text);
+        break;
+      case 'thinking':
+        // Skip thinking blocks — they're internal reasoning
+        break;
+      case 'tool_use':
+        // Skip tool_use blocks — we track tool calls separately
+        break;
+      case 'tool_result':
+        // Tool results commonly contain full file or command output. They are
+        // ephemeral and can be very large; tool names are indexed separately.
+        break;
+    }
+  }
+  return parts.join('\n').trim();
+}
+
+/**
+ * Extract tool call names from a message's content array.
+ */
+function extractToolCalls(content: unknown): string[] | undefined {
+  if (!Array.isArray(content)) return undefined;
+
+  const toolNames: string[] = [];
+  for (const block of content) {
+    if (!block || typeof block !== 'object') continue;
+    const b = block as Record<string, unknown>;
+    if ((b.type === 'tool_use' || b.type === 'toolCall') && typeof b.name === 'string') {
+      toolNames.push(b.name);
+    }
+  }
+  return toolNames.length > 0 ? toolNames : undefined;
+}
+
+/**
+ * Parse a Pi session JSONL file.
+ *
+ * @param filePath — Path to the .jsonl file
+ * @returns Parsed session data, or null if the file is invalid
+ */
+export function parseSessionFile(filePath: string): ParsedSession | null {
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const lines = content.split('\n').filter(line => line.trim());
+
+  if (lines.length === 0) return null;
+
+  let sessionId: string | null = null;
+  let sessionCwd: string | null = null;
+  let sessionTimestamp: string | null = null;
+  const messages: ParsedMessage[] = [];
+
+  for (const line of lines) {
+    let entry: JsonlEntry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue; // Skip malformed lines
+    }
+
+    switch (entry.type) {
+      case 'session':
+        sessionId = entry.id ?? null;
+        sessionCwd = entry.cwd ?? null;
+        sessionTimestamp = entry.timestamp ?? null;
+        break;
+
+      case 'message': {
+        if (!entry.message || !entry.id || !entry.timestamp) break;
+
+        const role = entry.message.role;
+        if (role !== 'user' && role !== 'assistant' && role !== 'system') break;
+
+        const textContent = extractTextContent(entry.message.content);
+        if (!textContent) break; // Skip empty messages
+
+        const toolCalls = role === 'assistant' ? extractToolCalls(entry.message.content) : undefined;
+
+        messages.push({
+          id: entry.id,
+          role,
+          content: textContent,
+          timestamp: entry.timestamp,
+          toolCalls,
+        });
+        break;
+      }
+      // Skip other entry types (model_change, thinking_level_change, custom, etc.)
+    }
+  }
+
+  if (!sessionId || !sessionCwd || !sessionTimestamp) return null;
+
+  // Decode project name from cwd-encoded directory name
+  // The directory is named like "--Users-chandrateja-Documents-pi-hermes-memory--"
+  // We extract the last segment as the project name
+  const project = sessionCwd.split('/').pop() ?? sessionCwd;
+
+  return {
+    id: sessionId,
+    project,
+    cwd: sessionCwd,
+    startedAt: sessionTimestamp,
+    endedAt: null, // We don't know when it ended from the JSONL
+    messages,
+  };
+}
+
+/**
+ * Get all session JSONL files for a project (or all projects).
+ *
+ * @param sessionsDir — Path to ~/.selesai/agent/sessions/
+ * @param projectDir — Optional: specific project directory name (e.g., "--Users-...--")
+ * @returns Array of file paths
+ */
+export function getSessionFiles(sessionsDir: string, projectDir?: string): string[] {
+  if (projectDir) {
+    const dir = path.join(sessionsDir, projectDir);
+    if (!fs.existsSync(dir)) return [];
+    return fs.readdirSync(dir)
+      .filter(f => f.endsWith('.jsonl'))
+      .map(f => path.join(dir, f));
+  }
+
+  // All projects
+  if (!fs.existsSync(sessionsDir)) return [];
+  const files: string[] = [];
+  for (const entry of fs.readdirSync(sessionsDir)) {
+    const entryPath = path.join(sessionsDir, entry);
+    const stat = fs.statSync(entryPath);
+    if (stat.isDirectory()) {
+      // Scan .jsonl files inside project subdirectories
+      for (const f of fs.readdirSync(entryPath)) {
+        if (f.endsWith('.jsonl')) {
+          files.push(path.join(entryPath, f));
+        }
+      }
+    } else if (stat.isFile() && entry.endsWith('.jsonl')) {
+      // Also pick up root-level .jsonl files
+      files.push(entryPath);
+    }
+  }
+  return files;
+}
+
+/**
+ * Decode a project directory name to a human-readable project name.
+ * "--Users-chandrateja-Documents-pi-hermes-memory--" → "pi-hermes-memory"
+ */
+export function decodeProjectDir(dirName: string): string {
+  // Remove leading/trailing dashes
+  const cleaned = dirName.replace(/^-+|-+$/g, '');
+  // Split by dash and take the last segment (project name)
+  const segments = cleaned.split('-');
+  return segments[segments.length - 1] ?? cleaned;
+}

package/dist/extensions/pi-hermes-memory/src/store/session-search.ts

@@ -0,0 +1,234 @@
+import { DatabaseManager } from './db.js';
+import {
+  buildFallbackFts5Query,
+  buildNaturalLanguageFallbackQuery,
+  hasExplicitFts5Operator,
+  isFts5QueryError,
+  normalizeFts5Query,
+  normalizeNaturalLanguageFts5Query,
+} from './fts-query.js';
+
+/**
+ * Search result from session history.
+ */
+export interface SessionSearchResult {
+  sessionId: string;
+  project: string;
+  role: string;
+  content: string;
+  timestamp: string;
+  snippet: string;
+}
+
+/**
+ * Search options for session search.
+ */
+export interface SessionSearchOptions {
+  /** Maximum number of results (default: 10) */
+  limit?: number;
+  /** Filter by project name */
+  project?: string;
+  /** Filter by role: 'user', 'assistant', 'system' */
+  role?: string;
+  /** Only return messages after this date (ISO string) */
+  since?: string;
+}
+
+type SearchMatch =
+  | { type: 'fts'; query: string }
+  | { type: 'like'; terms: string[] };
+
+const QUERY_TOKEN_PATTERN = /"([^"]*)"|(\S+)/g;
+const NATURAL_LANGUAGE_CONNECTORS = new Set(['and', 'or', 'not', 'near']);
+
+function escapeLikePattern(text: string): string {
+  return text.replace(/[\\%_]/g, '\\$&');
+}
+
+function collectLikeTerms(query: string): string[] {
+  const terms: string[] = [];
+
+  for (const match of query.matchAll(QUERY_TOKEN_PATTERN)) {
+    const phrase = match[1];
+    const term = match[2];
+    if (phrase === undefined && term && NATURAL_LANGUAGE_CONNECTORS.has(term.toLowerCase())) {
+      continue;
+    }
+
+    const rawValue = phrase ?? term ?? '';
+    if (rawValue.length > 0) terms.push(rawValue);
+  }
+
+  return terms;
+}
+
+function mapRows(rows: Array<{
+  session_id: string;
+  project: string;
+  role: string;
+  content: string;
+  timestamp: string;
+  snippet: string;
+}>): SessionSearchResult[] {
+  return rows.map(row => ({
+    sessionId: row.session_id,
+    project: row.project,
+    role: row.role,
+    content: row.content,
+    timestamp: row.timestamp,
+    snippet: row.snippet,
+  }));
+}
+
+/**
+ * Search across indexed session messages using FTS5.
+ *
+ * @param dbManager — Database manager instance
+ * @param query — FTS5 search query
+ * @param options — Search options
+ * @returns Array of search results with snippets
+ */
+export function searchSessions(
+  dbManager: DatabaseManager,
+  query: string,
+  options: SessionSearchOptions = {}
+): SessionSearchResult[] {
+  if (query.trim().length === 0) {
+    return [];
+  }
+
+  const db = dbManager.getDb();
+  const { limit = 10, project, role, since } = options;
+
+  let ftsParseError = false;
+
+  const executeSearch = (match: SearchMatch): SessionSearchResult[] => {
+    const conditions: string[] = [];
+    const params: unknown[] = [];
+
+    if (match.type === 'fts') {
+      // FTS5 match condition — use subquery for reliable rowid matching
+      conditions.push('m.rowid IN (SELECT rowid FROM message_fts WHERE message_fts MATCH ?)');
+      params.push(match.query);
+    } else {
+      if (match.terms.length === 0) {
+        return [];
+      }
+      const likeConditions = match.terms.map(() => `m.content LIKE ? ESCAPE '\\'`);
+      conditions.push(`(${likeConditions.join(' OR ')})`);
+      for (const term of match.terms) {
+        params.push(`%${escapeLikePattern(term)}%`);
+      }
+    }
+
+    // Project filter
+    if (project) {
+      conditions.push('s.project = ?');
+      params.push(project);
+    }
+
+    // Role filter
+    if (role) {
+      conditions.push('m.role = ?');
+      params.push(role);
+    }
+
+    // Date filter
+    if (since) {
+      conditions.push('m.timestamp >= ?');
+      params.push(since);
+    }
+
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+
+    const sql = `
+      SELECT
+        m.session_id,
+        s.project,
+        m.role,
+        m.content,
+        m.timestamp,
+        m.content as snippet
+      FROM messages m
+      JOIN sessions s ON s.id = m.session_id
+      ${whereClause}
+      ORDER BY m.timestamp DESC
+      LIMIT ?
+    `;
+
+    try {
+      const rows = db.prepare(sql).all(...params, limit) as Array<{
+        session_id: string;
+        project: string;
+        role: string;
+        content: string;
+        timestamp: string;
+        snippet: string;
+      }>;
+
+      return mapRows(rows);
+    } catch (err) {
+      if (match.type === 'fts' && isFts5QueryError(err)) {
+        ftsParseError = true;
+        return [];
+      }
+      throw err;
+    }
+  };
+
+  const normalizedQuery = normalizeFts5Query(query);
+  if (normalizedQuery.length === 0) {
+    return [];
+  }
+
+  const exactResults = executeSearch({ type: 'fts', query: normalizedQuery });
+  if (exactResults.length > 0) {
+    return exactResults;
+  }
+
+  const explicitOperatorQuery = hasExplicitFts5Operator(query);
+  if (explicitOperatorQuery) {
+    // Same recovery as searchMemories: only when the raw operator query fails
+    // to parse do we retry it as natural language; valid operator queries that
+    // match nothing keep their exact semantics.
+    if (!ftsParseError) {
+      return exactResults;
+    }
+    const nlQuery = normalizeNaturalLanguageFts5Query(query);
+    if (nlQuery.length > 0 && nlQuery !== normalizedQuery) {
+      const nlResults = executeSearch({ type: 'fts', query: nlQuery });
+      if (nlResults.length > 0) {
+        return nlResults;
+      }
+      const nlFallback = buildNaturalLanguageFallbackQuery(query);
+      if (nlFallback && nlFallback !== nlQuery) {
+        const nlFallbackResults = executeSearch({ type: 'fts', query: nlFallback });
+        if (nlFallbackResults.length > 0) {
+          return nlFallbackResults;
+        }
+      }
+    }
+    const likeTerms = collectLikeTerms(query);
+    return executeSearch({ type: 'like', terms: likeTerms });
+  }
+
+  const fallbackQuery = buildFallbackFts5Query(query);
+  if (fallbackQuery && fallbackQuery !== normalizedQuery) {
+    const fallbackResults = executeSearch({ type: 'fts', query: fallbackQuery });
+    if (fallbackResults.length > 0) {
+      return fallbackResults;
+    }
+  }
+
+  const likeTerms = collectLikeTerms(query);
+  return executeSearch({ type: 'like', terms: likeTerms });
+}
+
+/**
+ * Get the total number of indexed messages.
+ */
+export function getIndexedMessageCount(dbManager: DatabaseManager): number {
+  const db = dbManager.getDb();
+  const result = db.prepare('SELECT COUNT(*) as count FROM messages').get() as { count: number };
+  return result.count;
+}