pi-sessions 0.5.1 → 0.7.0

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

@@ -1,12 +1,13 @@
 import { Type } from "typebox";
-import type { FileTouchOp, FileTouchSource, PathScope } from "../../session-search/normalize.js";
-import { safeParseTypeBoxJson } from "../typebox.js";
-import type { SqliteDatabase } from "./sqlite.js";
+import type { FileTouchOp, FileTouchSource, PathScope } from "../../session-search/normalize.ts";
+import { safeParseTypeBoxJson } from "../typebox.ts";
+import type { SqliteDatabase } from "./sqlite.ts";
 
-export const INDEX_SCHEMA_VERSION = 8;
+export const INDEX_SCHEMA_VERSION = 12;
 
 export type SessionOrigin = "handoff" | "fork" | "unknown_child";
 export type SessionLineageRelation =
+  | "self"
   | "parent"
   | "ancestor"
   | "child"
@@ -14,6 +15,8 @@ export type SessionLineageRelation =
   | "sibling"
   | "ancestor_sibling";
 
+export type SearchSort = "relevance" | "modified_desc" | "modified_asc";
+
 export interface SessionRow {
   sessionId: string;
   sessionPath: string;
@@ -58,7 +61,7 @@ export interface SessionRelatedSessionRow extends SessionLineageRow {
 export interface SessionTextChunkRow {
   id?: number | undefined;
   sessionId: string;
-  entryId?: string | undefined;
+  entryId: string;
   entryType: string;
   role?: string | undefined;
   ts: string;
@@ -89,9 +92,34 @@ export interface SearchSessionsParams {
   after?: string | undefined;
   before?: string | undefined;
   touched?: string[] | undefined;
+  changed?: string[] | undefined;
+  sort?: SearchSort | undefined;
   limit?: number | undefined;
   excludeSessionIds?: string[] | undefined;
-}
+  includeSessionIds?: string[] | undefined;
+  relativeToSessionId?: string | undefined;
+}
+
+export type SessionSearchEvidence =
+  | {
+      kind: "text";
+      sourceKind: string;
+      snippet: string;
+      score: number;
+      entryId: string;
+    }
+  | {
+      kind: "file_touch";
+      op: "read" | "changed";
+      query: string;
+      path: string;
+      entryId?: string | undefined;
+    }
+  | {
+      kind: "session_id";
+      match: "exact" | "prefix" | "substring";
+      score: number;
+    };
 
 export interface SearchSessionResult {
   sessionId: string;
@@ -108,8 +136,9 @@ export interface SearchSessionResult {
   sessionOrigin?: SessionOrigin | undefined;
   handoffGoal?: string | undefined;
   handoffNextTask?: string | undefined;
+  relation?: SessionLineageRelation | undefined;
   snippet: string;
-  matchedFiles: string[];
+  evidence: SessionSearchEvidence[];
   score: number;
   hitCount: number;
 }
@@ -131,6 +160,7 @@ export const SESSION_ORIGIN_SCHEMA = Type.Union([
   Type.Literal("unknown_child"),
 ]);
 export const SESSION_LINEAGE_RELATION_SCHEMA = Type.Union([
+  Type.Literal("self"),
   Type.Literal("parent"),
   Type.Literal("ancestor"),
   Type.Literal("child"),
@@ -150,7 +180,7 @@ export function parseRepoRoots(value: string): string[] {
 }
 
 export function escapeLikePrefix(value: string): string {
-  return value.replace(/[%_]/g, "\\$&");
+  return value.replace(/[%_\\]/g, "\\$&");
 }
 
 export function normalizeTimeFilter(value?: string): string | undefined {
@@ -160,7 +190,7 @@ export function normalizeTimeFilter(value?: string): string | undefined {
 
   const date = new Date(value);
   if (Number.isNaN(date.getTime())) {
-    return undefined;
+    throw new Error(`Invalid time filter value: ${value}`);
   }
 
   return date.toISOString();
@@ -174,48 +204,6 @@ export function sanitizeFilterValues(values?: string[]): string[] {
   return values.map((value) => value.trim()).filter((value) => value.length > 0);
 }
 
-export function boostIndependentHits(hitCount: number): number {
-  return hitCount > 1 ? (hitCount - 1) * 0.75 : 0;
-}
-
-export function buildFtsQuery(query: string): string | undefined {
-  const trimmed = query.trim();
-  if (!trimmed) {
-    return undefined;
-  }
-
-  if (trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length >= 2) {
-    const exact = sanitizeFtsToken(trimmed.slice(1, -1));
-    return exact ? quoteFtsToken(exact) : undefined;
-  }
-
-  const tokens = tokenizeSearchTerms(trimmed);
-  if (tokens.length === 0) {
-    return undefined;
-  }
-
-  return tokens.map(quoteFtsPrefixToken).join(" AND ");
-}
-
-export function tokenizeSearchTerms(query: string): string[] {
-  return query
-    .split(/\s+/)
-    .flatMap((token) => sanitizeFtsToken(token).split(/\s+/))
-    .filter((token) => token.length > 0);
-}
-
-export function sanitizeFtsToken(token: string): string {
-  return token.replace(/[^A-Za-z0-9_]+/g, " ").trim();
-}
-
-export function quoteFtsToken(token: string): string {
-  return `"${token.replace(/"/g, '""')}"`;
-}
-
-export function quoteFtsPrefixToken(token: string): string {
-  return `${quoteFtsToken(token)}*`;
-}
-
 export function compactSearchValue(value: string): string {
   return value.toLowerCase().replace(/[^a-z0-9]+/g, "");
 }
@@ -223,3 +211,10 @@ export function compactSearchValue(value: string): string {
 export function compactSessionId(value: string): string {
   return value.toLowerCase().replace(/-/g, "");
 }
+
+export function tokenizeSearchText(value: string): string[] {
+  return value
+    .split(/[^A-Za-z0-9_]+/g)
+    .map((token) => token.trim())
+    .filter((token) => token.length > 0);
+}

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

@@ -1,5 +1,6 @@
-export * from "./common.js";
-export * from "./lineage.js";
-export * from "./schema.js";
-export * from "./search.js";
-export * from "./store.js";
+export * from "./access.ts";
+export * from "./common.ts";
+export * from "./lineage.ts";
+export * from "./schema.ts";
+export * from "./search.ts";
+export * from "./store.ts";

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

@@ -1,5 +1,5 @@
 import { type Static, Type } from "typebox";
-import { parseTypeBoxRows, parseTypeBoxValue } from "../typebox.js";
+import { parseTypeBoxRows, parseTypeBoxValue } from "../typebox.ts";
 import {
   NULLABLE_STRING_SCHEMA,
   parseRepoRoots,
@@ -9,7 +9,7 @@ import {
   type SessionLineageRelation,
   type SessionLineageRow,
   type SessionRelatedSessionRow,
-} from "./common.js";
+} from "./common.ts";
 
 const SESSION_GRAPH_ROW_SCHEMA = Type.Object({
   sessionId: Type.String(),
@@ -160,6 +160,13 @@ export function getLineageSessions(
   return queryRelatedSessions(db, sessionId);
 }
 
+export function getLineageRelationMap(
+  db: SessionIndexDatabase,
+  sessionId: string,
+): Map<string, SessionLineageRelation> {
+  return new Map(getLineageSessions(db, sessionId).map((row) => [row.sessionId, row.relation]));
+}
+
 export function getParentSession(
   db: SessionIndexDatabase,
   sessionId: string,
@@ -339,6 +346,7 @@ function queryRelatedSessions(
           WHERE r.session_id = ?${relationFilter}
           ORDER BY
             CASE r.relation
+              WHEN 'self' THEN 0
               WHEN 'parent' THEN 1
               WHEN 'child' THEN 2
               WHEN 'sibling' THEN 3
@@ -364,6 +372,13 @@ function collectMaterializedLineageRows(
   childrenByParent: Map<string, string[]>,
 ): Map<string, MaterializedLineageRow> {
   const relations = new Map<string, MaterializedLineageRow>();
+  setMaterializedLineageRow(relations, {
+    sessionId,
+    relatedSessionId: sessionId,
+    relation: "self",
+    distance: 0,
+  });
+
   const visitedAncestors = new Set<string>();
   const ancestors: Array<{ sessionId: string; distance: number }> = [];
 
@@ -469,6 +484,8 @@ function setMaterializedLineageRow(
 
 function getLineageRelationPriority(relation: SessionLineageRelation): number {
   switch (relation) {
+    case "self":
+      return 0;
     case "parent":
       return 1;
     case "child":

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

@@ -0,0 +1,40 @@
+export interface QueryTermNode {
+  kind: "term";
+  value: string;
+  quoted: boolean;
+  prefix: boolean;
+}
+
+export interface QueryAndNode {
+  kind: "and";
+  children: SearchQueryNode[];
+}
+
+export interface QueryOrNode {
+  kind: "or";
+  children: SearchQueryNode[];
+}
+
+export interface QueryAdjacencyNode {
+  kind: "adjacency";
+  children: QueryTermNode[];
+}
+
+export interface QueryNotNode {
+  kind: "not";
+  child: SearchQueryNode;
+}
+
+export type SearchQueryNode =
+  | QueryTermNode
+  | QueryAndNode
+  | QueryOrNode
+  | QueryAdjacencyNode
+  | QueryNotNode;
+
+export class SearchQuerySyntaxError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "SearchQuerySyntaxError";
+  }
+}

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

@@ -0,0 +1,146 @@
+import { type SearchQueryNode, SearchQuerySyntaxError } from "./ast.ts";
+import { parseSearchQuery } from "./parser.ts";
+
+export interface CompiledSearchQuery {
+  match: string;
+  relaxedMatch?: string | undefined;
+  excludes: string[];
+  positiveTerms: string[];
+}
+
+export function compileSearchQuery(input: string): CompiledSearchQuery | undefined {
+  const ast = parseSearchQuery(input);
+  if (!ast) {
+    return undefined;
+  }
+
+  const { positive, excludes } = splitTopLevelExcludes(ast);
+  if (!positive) {
+    throw new SearchQuerySyntaxError(
+      "Negative-only searches are not supported yet. Add at least one positive search term.",
+    );
+  }
+
+  validateNoNestedNegation(positive);
+  for (const exclude of excludes) {
+    validateNoNestedNegation(exclude);
+  }
+
+  const match = compilePositiveNode(positive);
+  const relaxedMatch = compilePositiveNode(positive, "OR");
+
+  return {
+    match,
+    relaxedMatch: relaxedMatch === match ? undefined : relaxedMatch,
+    excludes: excludes.map((exclude) => compilePositiveNode(exclude)),
+    positiveTerms: collectPositiveTerms(positive),
+  };
+}
+
+interface SplitQuery {
+  positive: SearchQueryNode | undefined;
+  excludes: SearchQueryNode[];
+}
+
+function splitTopLevelExcludes(node: SearchQueryNode): SplitQuery {
+  if (node.kind === "not") {
+    return { positive: undefined, excludes: [node.child] };
+  }
+
+  if (node.kind !== "and") {
+    return { positive: node, excludes: [] };
+  }
+
+  const positives: SearchQueryNode[] = [];
+  const excludes: SearchQueryNode[] = [];
+
+  for (const child of flattenAndChildren(node)) {
+    if (child.kind === "not") {
+      excludes.push(child.child);
+      continue;
+    }
+
+    positives.push(child);
+  }
+
+  return {
+    positive: buildAndNode(positives),
+    excludes,
+  };
+}
+
+function flattenAndChildren(node: SearchQueryNode): SearchQueryNode[] {
+  if (node.kind !== "and") {
+    return [node];
+  }
+
+  return node.children.flatMap(flattenAndChildren);
+}
+
+function buildAndNode(children: SearchQueryNode[]): SearchQueryNode | undefined {
+  if (children.length === 0) {
+    return undefined;
+  }
+
+  if (children.length === 1) {
+    return children[0];
+  }
+
+  return { kind: "and", children };
+}
+
+function validateNoNestedNegation(node: SearchQueryNode): void {
+  switch (node.kind) {
+    case "not":
+      throw new SearchQuerySyntaxError(
+        "Negation is only supported as a top-level AND clause in this release.",
+      );
+    case "and":
+    case "or":
+    case "adjacency":
+      for (const child of node.children) {
+        validateNoNestedNegation(child);
+      }
+      return;
+    case "term":
+      return;
+  }
+}
+
+function compilePositiveNode(node: SearchQueryNode, adjacencyOp: "AND" | "OR" = "AND"): string {
+  switch (node.kind) {
+    case "term":
+      return compileTerm(node.value, node.prefix);
+    case "and":
+      return `(${node.children.map((child) => compilePositiveNode(child, adjacencyOp)).join(" AND ")})`;
+    case "or":
+      return `(${node.children.map((child) => compilePositiveNode(child, adjacencyOp)).join(" OR ")})`;
+    case "adjacency":
+      return `(${node.children.map((child) => compileTerm(child.value, child.prefix)).join(` ${adjacencyOp} `)})`;
+    case "not":
+      throw new SearchQuerySyntaxError(
+        "Negation is only supported as a top-level AND clause in this release.",
+      );
+  }
+}
+
+function compileTerm(value: string, prefix: boolean): string {
+  return `${quoteFtsValue(value)}${prefix ? "*" : ""}`;
+}
+
+function quoteFtsValue(value: string): string {
+  return `"${value.replace(/"/g, '""')}"`;
+}
+
+function collectPositiveTerms(node: SearchQueryNode): string[] {
+  switch (node.kind) {
+    case "term":
+      return [node.value];
+    case "and":
+    case "or":
+    case "adjacency":
+      return node.children.flatMap(collectPositiveTerms);
+    case "not":
+      return [];
+  }
+}

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);
+}