pi-sessions 0.6.0 → 0.7.1

package/extensions/shared/session-index/query/lexer.ts

@@ -0,0 +1,140 @@
+import { SearchQuerySyntaxError } from "./ast.ts";
+
+export type QueryToken =
+  | { kind: "term"; value: string; quoted: boolean; prefix: boolean; offset: number }
+  | { kind: "and"; offset: number }
+  | { kind: "or"; offset: number }
+  | { kind: "not"; offset: number }
+  | { kind: "leftParen"; offset: number }
+  | { kind: "rightParen"; offset: number };
+
+export function lexSearchQuery(input: string): QueryToken[] {
+  const tokens: QueryToken[] = [];
+  let index = 0;
+
+  while (index < input.length) {
+    const char = input[index];
+    if (isWhitespace(char)) {
+      index += 1;
+      continue;
+    }
+
+    if (char === "(") {
+      tokens.push({ kind: "leftParen", offset: index });
+      index += 1;
+      continue;
+    }
+
+    if (char === ")") {
+      tokens.push({ kind: "rightParen", offset: index });
+      index += 1;
+      continue;
+    }
+
+    if (char === '"') {
+      const token = readQuotedTerm(input, index);
+      tokens.push(token.token);
+      index = token.nextIndex;
+      continue;
+    }
+
+    if (char === "-" && isNegationBoundary(input, index)) {
+      tokens.push({ kind: "not", offset: index });
+      index += 1;
+      continue;
+    }
+
+    const token = readUnquotedToken(input, index);
+    tokens.push(token.token);
+    index = token.nextIndex;
+  }
+
+  return tokens;
+}
+
+function readQuotedTerm(input: string, start: number): { token: QueryToken; nextIndex: number } {
+  let index = start + 1;
+  let value = "";
+
+  while (index < input.length) {
+    const char = input[index];
+    if (char === '"') {
+      const afterQuote = index + 1;
+      const hasPrefix = input[afterQuote] === "*";
+      if (value.length === 0) {
+        throw new SearchQuerySyntaxError(`Empty quoted term at offset ${start}`);
+      }
+      return {
+        token: { kind: "term", value, quoted: true, prefix: hasPrefix, offset: start },
+        nextIndex: hasPrefix ? afterQuote + 1 : afterQuote,
+      };
+    }
+
+    value += char;
+    index += 1;
+  }
+
+  throw new SearchQuerySyntaxError(`Unclosed quote at offset ${start}`);
+}
+
+function readUnquotedToken(input: string, start: number): { token: QueryToken; nextIndex: number } {
+  let index = start;
+  let value = "";
+
+  while (index < input.length) {
+    const char = input[index];
+    if (isWhitespace(char) || char === "(" || char === ")" || char === '"') {
+      break;
+    }
+
+    value += char;
+    index += 1;
+  }
+
+  if (value.length === 0) {
+    throw new SearchQuerySyntaxError(`Unexpected character at offset ${start}`);
+  }
+
+  const upper = value.toUpperCase();
+  if (upper === "AND") {
+    return { token: { kind: "and", offset: start }, nextIndex: index };
+  }
+  if (upper === "OR") {
+    return { token: { kind: "or", offset: start }, nextIndex: index };
+  }
+  if (upper === "NOT") {
+    return { token: { kind: "not", offset: start }, nextIndex: index };
+  }
+
+  const firstStar = value.indexOf("*");
+  if (firstStar >= 0 && firstStar !== value.length - 1) {
+    throw new SearchQuerySyntaxError(`Only trailing * is supported at offset ${start}`);
+  }
+
+  const hasPrefix = value.endsWith("*");
+  const termValue = hasPrefix ? value.slice(0, -1) : value;
+  if (termValue.length === 0) {
+    throw new SearchQuerySyntaxError(`Empty prefix term at offset ${start}`);
+  }
+
+  return {
+    token: { kind: "term", value: termValue, quoted: false, prefix: true, offset: start },
+    nextIndex: index,
+  };
+}
+
+function isNegationBoundary(input: string, index: number): boolean {
+  if (index > 0) {
+    const previous = input[index - 1];
+    if (!isWhitespace(previous) && previous !== "(") {
+      return false;
+    }
+  }
+
+  const next = input[index + 1];
+  return next !== undefined && !isWhitespace(next) && next !== ")";
+}
+
+function isWhitespace(value: string | undefined): boolean {
+  return value !== undefined && /\s/.test(value);
+}

package/extensions/shared/session-index/query/parser.ts

@@ -0,0 +1,178 @@
+import {
+  type QueryAdjacencyNode,
+  type QueryAndNode,
+  type QueryNotNode,
+  type QueryOrNode,
+  type QueryTermNode,
+  type SearchQueryNode,
+  SearchQuerySyntaxError,
+} from "./ast.ts";
+import { lexSearchQuery, type QueryToken } from "./lexer.ts";
+
+export function parseSearchQuery(input: string): SearchQueryNode | undefined {
+  const tokens = lexSearchQuery(input);
+  if (tokens.length === 0) {
+    return undefined;
+  }
+
+  const parser = new Parser(tokens);
+  return parser.parse();
+}
+
+class Parser {
+  private index = 0;
+
+  constructor(private readonly tokens: QueryToken[]) {}
+
+  parse(): SearchQueryNode {
+    const node = this.parseOr();
+    const token = this.peek();
+    if (token) {
+      throw new SearchQuerySyntaxError(`Unexpected token at offset ${token.offset}`);
+    }
+    return node;
+  }
+
+  private parseOr(): SearchQueryNode {
+    const children = [this.parseAnd()];
+
+    while (this.match("or")) {
+      children.push(this.parseAnd());
+    }
+
+    return buildOrNode(children);
+  }
+
+  private parseAnd(): SearchQueryNode {
+    const children = [this.parseAdjacencyRun()];
+
+    while (true) {
+      if (this.match("and")) {
+        children.push(this.parseAdjacencyRun());
+        continue;
+      }
+
+      if (this.startsUnary(this.peek())) {
+        children.push(this.parseAdjacencyRun());
+        continue;
+      }
+
+      break;
+    }
+
+    return buildAndNode(children);
+  }
+
+  private parseAdjacencyRun(): SearchQueryNode {
+    const first = this.peek();
+    if (!isUnquotedTerm(first)) {
+      return this.parseUnary();
+    }
+
+    const children: QueryTermNode[] = [];
+    while (true) {
+      const token = this.peek();
+      if (!isUnquotedTerm(token)) {
+        break;
+      }
+
+      this.index += 1;
+      children.push({
+        kind: "term",
+        value: token.value,
+        quoted: token.quoted,
+        prefix: token.prefix,
+      });
+    }
+
+    return buildAdjacencyNode(children);
+  }
+
+  private parseUnary(): SearchQueryNode {
+    const token = this.peek();
+    if (token?.kind === "not") {
+      this.index += 1;
+      const child = this.parseUnary();
+      return { kind: "not", child } satisfies QueryNotNode;
+    }
+
+    return this.parsePrimary();
+  }
+
+  private parsePrimary(): SearchQueryNode {
+    const token = this.peek();
+    if (!token) {
+      throw new SearchQuerySyntaxError("Unexpected end of query");
+    }
+
+    if (token.kind === "term") {
+      this.index += 1;
+      return {
+        kind: "term",
+        value: token.value,
+        quoted: token.quoted,
+        prefix: token.prefix,
+      } satisfies QueryTermNode;
+    }
+
+    if (token.kind === "leftParen") {
+      this.index += 1;
+      const node = this.parseOr();
+      const next = this.peek();
+      if (next?.kind !== "rightParen") {
+        throw new SearchQuerySyntaxError(`Unclosed parenthesis at offset ${token.offset}`);
+      }
+      this.index += 1;
+      return node;
+    }
+
+    throw new SearchQuerySyntaxError(`Expected term at offset ${token.offset}`);
+  }
+
+  private startsUnary(token: QueryToken | undefined): boolean {
+    return token?.kind === "term" || token?.kind === "leftParen" || token?.kind === "not";
+  }
+
+  private match(kind: "and" | "or"): boolean {
+    if (this.peek()?.kind !== kind) {
+      return false;
+    }
+
+    this.index += 1;
+    return true;
+  }
+
+  private peek(): QueryToken | undefined {
+    return this.tokens[this.index];
+  }
+}
+
+function buildAndNode(children: SearchQueryNode[]): SearchQueryNode {
+  if (children.length === 1) {
+    return children[0] as SearchQueryNode;
+  }
+
+  return { kind: "and", children } satisfies QueryAndNode;
+}
+
+function buildOrNode(children: SearchQueryNode[]): SearchQueryNode {
+  if (children.length === 1) {
+    return children[0] as SearchQueryNode;
+  }
+
+  return { kind: "or", children } satisfies QueryOrNode;
+}
+
+function buildAdjacencyNode(children: QueryTermNode[]): SearchQueryNode {
+  if (children.length === 1) {
+    return children[0] as SearchQueryNode;
+  }
+
+  return { kind: "adjacency", children } satisfies QueryAdjacencyNode;
+}
+
+function isUnquotedTerm(
+  token: QueryToken | undefined,
+): token is Extract<QueryToken, { kind: "term" }> {
+  return token?.kind === "term" && !token.quoted;
+}

package/extensions/shared/session-index/schema.ts

@@ -18,10 +18,11 @@ export function ensureIndexDir(dir: string): string {
 
 export function openIndexDatabase(
   dbPath: string,
-  options?: { create?: boolean; timeoutMs?: number },
+  options?: { create?: boolean; mode?: "read" | "write"; timeoutMs?: number | undefined },
 ): SessionIndexDatabase {
   const create = options?.create ?? true;
-  return openSqlite(dbPath, { create, timeoutMs: options?.timeoutMs });
+  const readonly = options?.mode === "read";
+  return openSqlite(dbPath, { create, readonly, timeoutMs: options?.timeoutMs });
 }
 
 export function initializeSchema(db: SessionIndexDatabase): void {
@@ -61,6 +62,17 @@ export function initializeSchema(db: SessionIndexDatabase): void {
     CREATE INDEX IF NOT EXISTS sessions_parent_id_idx ON sessions(parent_session_id);
     CREATE INDEX IF NOT EXISTS sessions_parent_path_idx ON sessions(parent_session_path);
 
+    CREATE TABLE IF NOT EXISTS session_repo_roots (
+      session_id TEXT NOT NULL,
+      repo_root TEXT NOT NULL,
+      repo_basename TEXT NOT NULL,
+      PRIMARY KEY (session_id, repo_root),
+      FOREIGN KEY (session_id) REFERENCES sessions(session_id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS session_repo_roots_root_idx ON session_repo_roots(repo_root);
+    CREATE INDEX IF NOT EXISTS session_repo_roots_basename_idx ON session_repo_roots(repo_basename);
+
     CREATE TABLE IF NOT EXISTS session_lineage_relations (
       session_id TEXT NOT NULL,
       related_session_id TEXT NOT NULL,
@@ -79,7 +91,7 @@ export function initializeSchema(db: SessionIndexDatabase): void {
     CREATE TABLE IF NOT EXISTS session_text_chunks (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       session_id TEXT NOT NULL,
-      entry_id TEXT,
+      entry_id TEXT NOT NULL,
       entry_type TEXT NOT NULL,
       role TEXT,
       ts TEXT NOT NULL,
@@ -94,7 +106,8 @@ export function initializeSchema(db: SessionIndexDatabase): void {
     CREATE VIRTUAL TABLE IF NOT EXISTS session_text_chunks_fts USING fts5(
       text,
       content='session_text_chunks',
-      content_rowid='id'
+      content_rowid='id',
+      tokenize = 'unicode61 remove_diacritics 2 tokenchars ''_'''
     );
 
     CREATE TRIGGER IF NOT EXISTS session_text_chunks_fts_ai
@@ -164,8 +177,9 @@ export function getIndexStatus(dbPath: string): SessionIndexStatus {
     return { dbPath, exists: false };
   }
 
-  const db = openIndexDatabase(dbPath, { create: false });
+  let db: SessionIndexDatabase | undefined;
   try {
+    db = openIndexDatabase(dbPath, { create: false, mode: "read" });
     const schemaVersionRaw = getMetadata(db, "schema_version");
     const lastFullReindexAt = getMetadata(db, "indexed_at");
     const sessionCountRow = parseTypeBoxValue(
@@ -181,7 +195,9 @@ export function getIndexStatus(dbPath: string): SessionIndexStatus {
       sessionCount: sessionCountRow.count,
       lastFullReindexAt,
     };
+  } catch {
+    return { dbPath, exists: true };
   } finally {
-    db.close();
+    db?.close();
   }
 }

package/extensions/shared/session-index/scoring.ts

@@ -0,0 +1,80 @@
+const SESSION_ID_EXACT_SCORE = 100_000;
+const SESSION_ID_PREFIX_SCORE = 80_000;
+const SESSION_ID_SUBSTRING_SCORE = 60_000;
+const RECENCY_MAX_SCORE = 300;
+const RECENCY_HALF_LIFE_DAYS = 21;
+
+const TEXT_SOURCE_WEIGHTS = new Map<string, number>([
+  ["session_name", 360],
+  ["handoff_next_task", 300],
+  ["handoff_goal", 260],
+  ["user_text", 180],
+  ["assistant_text", 150],
+  ["bash_command", 140],
+  ["tool_result", 110],
+  ["bash_output", 90],
+]);
+
+export const MAX_SCORING_TEXT_HITS_PER_SESSION = 5;
+export const MAX_TEXT_EVIDENCE_PER_SESSION = 20;
+export const DEFAULT_SESSION_SEARCH_LIMIT = 50;
+export const MAX_SESSION_SEARCH_LIMIT = 500;
+export const MIN_TEXT_OVERFETCH_LIMIT = 200;
+export const TEXT_OVERFETCH_MULTIPLIER = 25;
+export const MAX_TEXT_OVERFETCH_LIMIT = 5_000;
+export const MAX_FILTERED_SESSION_CANDIDATES = 10_000;
+
+export type SessionIdMatchKind = "exact" | "prefix" | "substring";
+
+export interface SessionIdScore {
+  kind: SessionIdMatchKind;
+  score: number;
+}
+
+export function scoreSessionIdMatch(kind: SessionIdMatchKind, matchedLength = 0): number {
+  switch (kind) {
+    case "exact":
+      return SESSION_ID_EXACT_SCORE;
+    case "prefix":
+      return SESSION_ID_PREFIX_SCORE + matchedLength;
+    case "substring":
+      return SESSION_ID_SUBSTRING_SCORE + matchedLength;
+  }
+}
+
+export function scoreTextHit(sourceKind: string, rankIndex: number): number {
+  return getSourceWeight(sourceKind) / (rankIndex + 1);
+}
+
+export function scoreRecency(modifiedAt: string, nowMs: number): number {
+  const modifiedMs = new Date(modifiedAt).getTime();
+  if (Number.isNaN(modifiedMs)) {
+    return 0;
+  }
+
+  const ageDays = Math.max(0, (nowMs - modifiedMs) / 86_400_000);
+  return RECENCY_MAX_SCORE * 0.5 ** (ageDays / RECENCY_HALF_LIFE_DAYS);
+}
+
+export function buildTextOverfetchLimit(resultLimit: number): number {
+  return Math.min(
+    MAX_TEXT_OVERFETCH_LIMIT,
+    Math.max(MIN_TEXT_OVERFETCH_LIMIT, resultLimit * TEXT_OVERFETCH_MULTIPLIER),
+  );
+}
+
+export function normalizeResultLimit(value: number | undefined): number {
+  if (value === undefined) {
+    return DEFAULT_SESSION_SEARCH_LIMIT;
+  }
+
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error("limit must be greater than 0");
+  }
+
+  return Math.min(MAX_SESSION_SEARCH_LIMIT, Math.trunc(value));
+}
+
+function getSourceWeight(sourceKind: string): number {
+  return TEXT_SOURCE_WEIGHTS.get(sourceKind) ?? 120;
+}