pi-sessions 0.1.0

package/extensions/session-search/hooks.ts

@@ -0,0 +1,350 @@
+import { existsSync } from "node:fs";
+import type { ImageContent, TextContent } from "@mariozechner/pi-ai";
+import {
+  isToolCallEventType,
+  type ToolCallEvent,
+  type ToolResultEvent,
+} from "@mariozechner/pi-coding-agent";
+import {
+  clearSessionIndexedData,
+  getIndexStatus,
+  getSessionById,
+  INDEX_SCHEMA_VERSION,
+  insertSessionFileTouch,
+  insertTextChunk,
+  openIndexDatabase,
+  rebuildSessionLineageRelations,
+  type SessionLineageRow,
+  type SessionOrigin,
+  setMetadata,
+  upsertSession,
+} from "../shared/session-index/index.js";
+import { type ExtractedSessionRecord, extractSessionRecord } from "./extract.js";
+
+const TOOL_RESULT_TEXT_LIMIT = 500;
+
+type TrackedToolName = "read" | "edit" | "write";
+
+export interface PendingToolCall {
+  toolCallId: string;
+  toolName: TrackedToolName;
+  path: string;
+}
+
+export interface FinalizedToolCall extends PendingToolCall {
+  isError: boolean;
+  resultText: string;
+}
+
+export interface SessionHookStateSnapshot {
+  currentSessionFile?: string | undefined;
+  currentCwd?: string | undefined;
+  pendingToolCalls: PendingToolCall[];
+  finalizedToolCalls: FinalizedToolCall[];
+  lastFlushedSessionFile?: string | undefined;
+}
+
+export interface SessionHookController {
+  getState(): SessionHookStateSnapshot;
+  handleSessionStart(sessionFile: string | undefined, cwd: string): Promise<boolean>;
+  handleSessionSwitch(
+    previousSessionFile: string | undefined,
+    sessionFile: string | undefined,
+    cwd: string,
+    sessionOrigin?: SessionOrigin,
+  ): Promise<boolean>;
+  handleSessionFork(
+    previousSessionFile: string | undefined,
+    sessionFile: string | undefined,
+    cwd: string,
+  ): Promise<boolean>;
+  handleToolCall(event: ToolCallEvent, sessionFile: string | undefined, cwd: string): void;
+  handleToolResult(event: ToolResultEvent): void;
+  handleTurnEnd(sessionFile: string | undefined, cwd: string): Promise<boolean>;
+  handleSessionTree(sessionFile: string | undefined, cwd: string): Promise<boolean>;
+  handleSessionCompact(sessionFile: string | undefined, cwd: string): Promise<boolean>;
+  handleSessionShutdown(sessionFile: string | undefined, cwd: string): Promise<boolean>;
+}
+
+interface SessionHookState {
+  currentSessionFile?: string | undefined;
+  currentCwd?: string | undefined;
+  pendingToolCalls: Map<string, PendingToolCall>;
+  finalizedToolCalls: Map<string, FinalizedToolCall>;
+  lastFlushedSessionFile?: string | undefined;
+}
+
+export function createSessionHookController(options: { indexPath: string }): SessionHookController {
+  const { indexPath } = options;
+  const state: SessionHookState = {
+    pendingToolCalls: new Map(),
+    finalizedToolCalls: new Map(),
+  };
+
+  return {
+    getState() {
+      return {
+        currentSessionFile: state.currentSessionFile,
+        currentCwd: state.currentCwd,
+        pendingToolCalls: [...state.pendingToolCalls.values()],
+        finalizedToolCalls: [...state.finalizedToolCalls.values()],
+        lastFlushedSessionFile: state.lastFlushedSessionFile,
+      };
+    },
+    async handleSessionStart(sessionFile, cwd) {
+      attachSession(state, sessionFile, cwd);
+      return syncAttachedSession(indexPath, state, "session_start");
+    },
+    async handleSessionSwitch(previousSessionFile, sessionFile, cwd, sessionOrigin) {
+      const previousSynced = syncSessionFile(indexPath, previousSessionFile, "session_switch");
+      attachSession(state, sessionFile, cwd);
+      const currentSynced = syncAttachedSession(indexPath, state, "session_switch", sessionOrigin);
+      return previousSynced || currentSynced;
+    },
+    async handleSessionFork(previousSessionFile, sessionFile, cwd) {
+      const previousSynced = syncSessionFile(indexPath, previousSessionFile, "session_fork");
+      attachSession(state, sessionFile, cwd);
+      const currentSynced = syncAttachedSession(indexPath, state, "session_fork", "fork");
+      return previousSynced || currentSynced;
+    },
+    handleToolCall(event, sessionFile, cwd) {
+      attachSession(state, sessionFile, cwd);
+      const pendingToolCall = buildPendingToolCall(event);
+      if (!pendingToolCall) {
+        return;
+      }
+
+      state.pendingToolCalls.set(event.toolCallId, pendingToolCall);
+    },
+    handleToolResult(event) {
+      const pendingToolCall = state.pendingToolCalls.get(event.toolCallId);
+      if (!pendingToolCall) {
+        return;
+      }
+
+      state.pendingToolCalls.delete(event.toolCallId);
+      state.finalizedToolCalls.set(event.toolCallId, {
+        ...pendingToolCall,
+        isError: event.isError,
+        resultText: summarizeToolResultText(event.toolName, event.content),
+      });
+    },
+    async handleTurnEnd(sessionFile, cwd) {
+      attachSession(state, sessionFile, cwd);
+      const synced = syncAttachedSession(indexPath, state, "turn_end");
+      clearTurnState(state);
+      return synced;
+    },
+    async handleSessionTree(sessionFile, cwd) {
+      attachSession(state, sessionFile, cwd);
+      return syncAttachedSession(indexPath, state, "session_tree");
+    },
+    async handleSessionCompact(sessionFile, cwd) {
+      attachSession(state, sessionFile, cwd);
+      return syncAttachedSession(indexPath, state, "session_compact");
+    },
+    async handleSessionShutdown(sessionFile, cwd) {
+      attachSession(state, sessionFile, cwd);
+      const synced = syncAttachedSession(indexPath, state, "session_shutdown");
+      clearTurnState(state);
+      state.currentSessionFile = undefined;
+      state.currentCwd = undefined;
+      return synced;
+    },
+  };
+}
+
+function attachSession(
+  state: SessionHookState,
+  sessionFile: string | undefined,
+  cwd: string,
+): void {
+  if (sessionFile !== undefined) {
+    state.currentSessionFile = sessionFile;
+  }
+
+  state.currentCwd = cwd;
+}
+
+function syncAttachedSession(
+  indexPath: string,
+  state: SessionHookState,
+  eventType: string,
+  sessionOrigin?: SessionOrigin,
+): boolean {
+  return syncSessionFile(indexPath, state.currentSessionFile, eventType, state, sessionOrigin);
+}
+
+function syncSessionFile(
+  indexPath: string,
+  sessionFile: string | undefined,
+  eventType: string,
+  state?: SessionHookState,
+  sessionOrigin?: SessionOrigin,
+): boolean {
+  if (!sessionFile || !existsSync(sessionFile)) {
+    return false;
+  }
+
+  const status = getIndexStatus(indexPath);
+  if (!status.exists || status.schemaVersion !== INDEX_SCHEMA_VERSION) {
+    return false;
+  }
+
+  const extracted = extractSessionRecord(sessionFile);
+  if (!extracted) {
+    return false;
+  }
+
+  const db = openIndexDatabase(indexPath, { create: false });
+  try {
+    db.transaction(() => {
+      const existingSession = getSessionById(db, extracted.sessionId);
+      const sessionRow = mergeSessionLineage(extracted, existingSession, sessionOrigin);
+      upsertSession(db, sessionRow, "hook");
+      if (shouldRefreshLineageRelations(existingSession, sessionRow)) {
+        rebuildSessionLineageRelations(db);
+      }
+      clearSessionIndexedData(db, extracted.sessionId);
+
+      for (const chunk of extracted.chunks) {
+        insertTextChunk(db, { sessionId: extracted.sessionId, ...chunk });
+      }
+
+      for (const fileTouch of extracted.fileTouches) {
+        insertSessionFileTouch(db, { sessionId: extracted.sessionId, ...fileTouch });
+      }
+
+      setMetadata(db, "hook_updated_at", new Date().toISOString());
+      setMetadata(db, "hook_last_event", eventType);
+    })();
+  } finally {
+    db.close();
+  }
+
+  if (state) {
+    state.lastFlushedSessionFile = sessionFile;
+  }
+
+  return true;
+}
+
+function mergeSessionLineage(
+  extracted: ExtractedSessionRecord,
+  existing: SessionLineageRow | undefined,
+  sessionOrigin?: SessionOrigin,
+): ExtractedSessionRecord {
+  const parentSessionPath = extracted.parentSessionPath ?? existing?.parentSessionPath;
+  const parentSessionId = extracted.parentSessionId ?? existing?.parentSessionId;
+  const nextOrigin = resolveSessionOrigin(
+    sessionOrigin,
+    extracted.sessionOrigin,
+    existing?.sessionOrigin,
+  );
+
+  return {
+    ...extracted,
+    parentSessionPath,
+    parentSessionId,
+    sessionOrigin: parentSessionPath ? (nextOrigin ?? "unknown_child") : undefined,
+  };
+}
+
+function resolveSessionOrigin(
+  explicit: SessionOrigin | undefined,
+  extracted: SessionOrigin | undefined,
+  existing: SessionOrigin | undefined,
+): SessionOrigin | undefined {
+  if (explicit) {
+    return explicit;
+  }
+
+  // Preserve a specific origin when the extracted record only knows "unknown_child"
+  if (extracted === "unknown_child" && existing && existing !== "unknown_child") {
+    return existing;
+  }
+
+  return extracted ?? existing;
+}
+
+function shouldRefreshLineageRelations(
+  existing: SessionLineageRow | undefined,
+  next: ExtractedSessionRecord,
+): boolean {
+  if (!existing) {
+    return true;
+  }
+
+  return (
+    existing.sessionPath !== next.sessionPath ||
+    existing.parentSessionPath !== next.parentSessionPath ||
+    existing.parentSessionId !== next.parentSessionId
+  );
+}
+
+function buildPendingToolCall(event: ToolCallEvent): PendingToolCall | undefined {
+  if (isToolCallEventType("read", event)) {
+    return buildTrackedToolCall(event.toolCallId, "read", event.input.path);
+  }
+
+  if (isToolCallEventType("edit", event)) {
+    return buildTrackedToolCall(event.toolCallId, "edit", event.input.path);
+  }
+
+  if (isToolCallEventType("write", event)) {
+    return buildTrackedToolCall(event.toolCallId, "write", event.input.path);
+  }
+
+  return undefined;
+}
+
+function buildTrackedToolCall(
+  toolCallId: string,
+  toolName: TrackedToolName,
+  rawPath: string,
+): PendingToolCall | undefined {
+  const path = stringValue(rawPath);
+  if (!path) {
+    return undefined;
+  }
+
+  return {
+    toolCallId,
+    toolName,
+    path,
+  };
+}
+
+function summarizeToolResultText(
+  toolName: string,
+  content: Array<TextContent | ImageContent>,
+): string {
+  const text = content
+    .filter((part): part is TextContent => part.type === "text" && typeof part.text === "string")
+    .map((part) => part.text)
+    .join("\n")
+    .trim();
+
+  if (toolName === "write") {
+    return text;
+  }
+
+  return truncateText(text, TOOL_RESULT_TEXT_LIMIT);
+}
+
+function truncateText(text: string, limit: number): string {
+  if (text.length <= limit) {
+    return text;
+  }
+
+  return `${text.slice(0, limit)}…`;
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+
+function clearTurnState(state: SessionHookState): void {
+  state.pendingToolCalls.clear();
+  state.finalizedToolCalls.clear();
+}

package/extensions/session-search/normalize.ts

@@ -0,0 +1,170 @@
+import { existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export type FileTouchOp = "changed" | "read" | "touched";
+export type FileTouchSource = "tool_call" | "branch_summary_details" | "compaction_details";
+export type PathScope = "absolute" | "relative" | "basename";
+
+export interface NormalizedPathRecord {
+  rawPath: string;
+  absPath?: string | undefined;
+  cwdRelPath?: string | undefined;
+  repoRoot?: string | undefined;
+  repoRelPath?: string | undefined;
+  basename: string;
+  pathScope: PathScope;
+  op?: FileTouchOp | undefined;
+}
+
+export function normalizePathRecord(rawPath: string, cwd: string): NormalizedPathRecord {
+  const trimmedPath = rawPath.trim();
+  const expandedPath = expandHome(trimmedPath);
+  const pathScope = classifyPathScope(expandedPath);
+  const absPath = resolveAbsolutePath(expandedPath, cwd);
+  const repoRoot = absPath ? deriveRepoRootForPath(absPath) : undefined;
+
+  return {
+    rawPath: trimmedPath,
+    absPath,
+    cwdRelPath: absPath ? toRelativePath(absPath, cwd) : undefined,
+    repoRoot,
+    repoRelPath: absPath && repoRoot ? toRelativePath(absPath, repoRoot) : undefined,
+    basename: deriveBasename(trimmedPath, absPath),
+    pathScope,
+  };
+}
+
+export function deriveRepoRootForPath(absPath: string): string | undefined {
+  let current = path.normalize(absPath);
+
+  while (true) {
+    if (existsSync(path.join(current, ".git"))) {
+      return current;
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return undefined;
+    }
+
+    current = parent;
+  }
+}
+
+export function deriveSessionRepoRoots(
+  cwd: string,
+  normalizedPaths: NormalizedPathRecord[],
+): string[] {
+  const repoRoots = new Set<string>();
+  if (cwd && path.isAbsolute(cwd)) {
+    const cwdRepoRoot = deriveRepoRootForPath(cwd);
+    if (cwdRepoRoot) {
+      repoRoots.add(cwdRepoRoot);
+    }
+  }
+
+  for (const normalizedPath of normalizedPaths) {
+    if (!normalizedPath.repoRoot || normalizedPath.op === "read") {
+      continue;
+    }
+
+    repoRoots.add(normalizedPath.repoRoot);
+  }
+
+  return [...repoRoots].sort();
+}
+
+export function matchesRepoRoot(repoRoot: string, repoQuery: string): boolean {
+  const normalizedRepoRoot = path.normalize(repoRoot);
+  const normalizedQuery = normalizeSearchPath(repoQuery);
+  if (!normalizedQuery) {
+    return false;
+  }
+
+  if (path.isAbsolute(normalizedQuery) || normalizedQuery.includes("/")) {
+    return normalizedRepoRoot === normalizedQuery || normalizedRepoRoot.endsWith(normalizedQuery);
+  }
+
+  return path.basename(normalizedRepoRoot) === normalizedQuery;
+}
+
+export function normalizeSearchPath(rawPath: string): string | undefined {
+  const trimmedPath = rawPath.trim();
+  if (!trimmedPath) {
+    return undefined;
+  }
+
+  const expandedPath = expandHome(trimmedPath);
+  return path.normalize(expandedPath).replace(/\\/g, "/");
+}
+
+function classifyPathScope(rawPath: string): PathScope {
+  if (path.isAbsolute(rawPath)) {
+    return "absolute";
+  }
+
+  if (rawPath.includes("/") || rawPath.includes("\\") || rawPath === "." || rawPath === "..") {
+    return "relative";
+  }
+
+  return "basename";
+}
+
+function expandHome(rawPath: string): string {
+  if (rawPath === "~") {
+    return os.homedir();
+  }
+
+  if (rawPath.startsWith(`~${path.sep}`) || rawPath.startsWith("~/")) {
+    return path.join(os.homedir(), rawPath.slice(2));
+  }
+
+  return rawPath;
+}
+
+function resolveAbsolutePath(rawPath: string, cwd: string): string | undefined {
+  if (!cwd || !path.isAbsolute(cwd)) {
+    return path.isAbsolute(rawPath) ? normalizeAbsolute(rawPath) : undefined;
+  }
+
+  if (path.isAbsolute(rawPath)) {
+    return normalizeAbsolute(rawPath);
+  }
+
+  return normalizeAbsolute(path.resolve(cwd, rawPath));
+}
+
+function normalizeAbsolute(absPath: string): string {
+  return path.normalize(absPath).replace(/\\/g, "/");
+}
+
+function toRelativePath(absPath: string, root: string): string | undefined {
+  if (!root || !path.isAbsolute(root)) {
+    return undefined;
+  }
+
+  const normalizedAbsPath = normalizeAbsolute(absPath);
+  const normalizedRoot = normalizeAbsolute(root);
+  if (!isWithinPath(normalizedAbsPath, normalizedRoot)) {
+    return undefined;
+  }
+
+  const relativePath = path.relative(normalizedRoot, normalizedAbsPath).replace(/\\/g, "/");
+  return relativePath || ".";
+}
+
+function isWithinPath(targetPath: string, basePath: string): boolean {
+  if (targetPath === basePath) {
+    return true;
+  }
+
+  return targetPath.startsWith(`${basePath}/`);
+}
+
+function deriveBasename(rawPath: string, absPath?: string): string {
+  const targetPath = absPath ?? rawPath;
+  const normalizedPath = targetPath.replace(/[\\/]+$/, "");
+  const basename = path.basename(normalizedPath);
+  return basename || rawPath;
+}

package/extensions/session-search/reindex.ts

@@ -0,0 +1,93 @@
+import { renameSync } from "node:fs";
+import { SessionManager } from "@mariozechner/pi-coding-agent";
+import {
+  createTempIndexPath,
+  initializeSchema,
+  insertSession,
+  insertSessionFileTouch,
+  insertTextChunk,
+  openIndexDatabase,
+  rebuildSessionLineageRelations,
+  type SessionIndexDatabase,
+  setMetadata,
+} from "../shared/session-index/index.js";
+import { extractSessionRecord, type SearchTextChunk, type SessionFileTouch } from "./extract.js";
+
+export interface ReindexOptions {
+  indexPath: string;
+}
+
+export interface ReindexResult {
+  sessionCount: number;
+  chunkCount: number;
+  indexPath: string;
+}
+
+export async function rebuildSessionIndex(options: ReindexOptions): Promise<ReindexResult> {
+  const finalIndexPath = options.indexPath;
+  const tempIndexPath = createTempIndexPath(finalIndexPath);
+  const sessionFiles = (await SessionManager.listAll()).map((session) => session.path);
+
+  const db = openIndexDatabase(tempIndexPath, { create: true });
+  let sessionCount: number;
+  let chunkCount: number;
+  try {
+    initializeSchema(db);
+    ({ sessionCount, chunkCount } = indexSessionFiles(db, sessionFiles));
+  } finally {
+    db.close();
+  }
+
+  renameSync(tempIndexPath, finalIndexPath);
+  return { sessionCount, chunkCount, indexPath: finalIndexPath };
+}
+
+function indexSessionFiles(
+  db: SessionIndexDatabase,
+  sessionFiles: string[],
+): { sessionCount: number; chunkCount: number } {
+  return db.transaction((files: string[]) => {
+    let sessionCount = 0;
+    let chunkCount = 0;
+
+    for (const sessionFile of files) {
+      const extracted = extractSessionRecord(sessionFile);
+      if (!extracted) {
+        continue;
+      }
+
+      insertSession(db, extracted, "full_reindex");
+      sessionCount += 1;
+      chunkCount += insertSessionChunks(db, extracted.sessionId, extracted.chunks);
+      insertSessionFileTouches(db, extracted.sessionId, extracted.fileTouches);
+    }
+
+    rebuildSessionLineageRelations(db);
+    setMetadata(db, "indexed_at", new Date().toISOString());
+    setMetadata(db, "session_source", "SessionManager.listAll()");
+
+    return { sessionCount, chunkCount };
+  })(sessionFiles);
+}
+
+function insertSessionChunks(
+  db: SessionIndexDatabase,
+  sessionId: string,
+  chunks: SearchTextChunk[],
+): number {
+  for (const chunk of chunks) {
+    insertTextChunk(db, { sessionId, ...chunk });
+  }
+
+  return chunks.length;
+}
+
+function insertSessionFileTouches(
+  db: SessionIndexDatabase,
+  sessionId: string,
+  fileTouches: SessionFileTouch[],
+): void {
+  for (const fileTouch of fileTouches) {
+    insertSessionFileTouch(db, { sessionId, ...fileTouch });
+  }
+}