pi-sessions 0.1.0

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

@@ -0,0 +1,417 @@
+import { type Static, Type } from "@sinclair/typebox";
+import { parseTypeBoxRows, parseTypeBoxValue } from "../typebox.js";
+import {
+  NULLABLE_STRING_SCHEMA,
+  parseRepoRoots,
+  SESSION_LINEAGE_RELATION_SCHEMA,
+  SESSION_ORIGIN_SCHEMA,
+  type SessionIndexDatabase,
+  type SessionLineageRelation,
+  type SessionLineageRow,
+  type SessionRelatedSessionRow,
+} from "./common.js";
+
+const SESSION_GRAPH_ROW_SCHEMA = Type.Object({
+  sessionId: Type.String(),
+  sessionPath: Type.String(),
+  parentSessionPath: NULLABLE_STRING_SCHEMA,
+  parentSessionId: NULLABLE_STRING_SCHEMA,
+});
+
+const SESSION_LINEAGE_QUERY_ROW_SCHEMA = Type.Object({
+  sessionId: Type.String(),
+  sessionPath: Type.String(),
+  sessionName: Type.String(),
+  firstUserPrompt: NULLABLE_STRING_SCHEMA,
+  cwd: Type.String(),
+  repoRootsJson: Type.String(),
+  modifiedAt: Type.String(),
+  parentSessionPath: NULLABLE_STRING_SCHEMA,
+  parentSessionId: NULLABLE_STRING_SCHEMA,
+  sessionOrigin: Type.Union([SESSION_ORIGIN_SCHEMA, Type.Null()]),
+  handoffGoal: NULLABLE_STRING_SCHEMA,
+  handoffNextTask: NULLABLE_STRING_SCHEMA,
+});
+
+const SESSION_RELATED_QUERY_ROW_SCHEMA = Type.Intersect([
+  SESSION_LINEAGE_QUERY_ROW_SCHEMA,
+  Type.Object({
+    relation: SESSION_LINEAGE_RELATION_SCHEMA,
+    distance: Type.Number(),
+  }),
+]);
+
+type SessionGraphNode = Static<typeof SESSION_GRAPH_ROW_SCHEMA> & {
+  resolvedParentSessionId?: string | undefined;
+};
+
+interface MaterializedLineageRow {
+  sessionId: string;
+  relatedSessionId: string;
+  relation: SessionLineageRelation;
+  distance: number;
+}
+
+function sessionLineageColumns(alias?: string): string {
+  const prefix = alias ? `${alias}.` : "";
+  return [
+    `${prefix}session_id as sessionId`,
+    `${prefix}session_path as sessionPath`,
+    `${prefix}session_name as sessionName`,
+    `${prefix}first_user_prompt as firstUserPrompt`,
+    `${prefix}cwd`,
+    `${prefix}repo_roots_json as repoRootsJson`,
+    `${prefix}modified_ts as modifiedAt`,
+    `${prefix}parent_session_path as parentSessionPath`,
+    `${prefix}parent_session_id as parentSessionId`,
+    `${prefix}session_origin as sessionOrigin`,
+    `${prefix}handoff_goal as handoffGoal`,
+    `${prefix}handoff_next_task as handoffNextTask`,
+  ].join(",\n          ");
+}
+
+function buildSessionLineageRow(
+  row: Static<typeof SESSION_LINEAGE_QUERY_ROW_SCHEMA>,
+): SessionLineageRow {
+  return {
+    sessionId: row.sessionId,
+    sessionPath: row.sessionPath,
+    sessionName: row.sessionName,
+    firstUserPrompt: row.firstUserPrompt ?? undefined,
+    cwd: row.cwd,
+    repoRoots: parseRepoRoots(row.repoRootsJson),
+    modifiedAt: row.modifiedAt,
+    parentSessionPath: row.parentSessionPath ?? undefined,
+    parentSessionId: row.parentSessionId ?? undefined,
+    sessionOrigin: row.sessionOrigin ?? undefined,
+    handoffGoal: row.handoffGoal ?? undefined,
+    handoffNextTask: row.handoffNextTask ?? undefined,
+  };
+}
+
+function buildRelatedSessionRow(
+  row: Static<typeof SESSION_RELATED_QUERY_ROW_SCHEMA>,
+): SessionRelatedSessionRow {
+  return {
+    ...buildSessionLineageRow(row),
+    relation: row.relation,
+    distance: row.distance,
+  };
+}
+
+export function getSessionById(
+  db: SessionIndexDatabase,
+  sessionId: string,
+): SessionLineageRow | undefined {
+  const row = db
+    .prepare(
+      `
+        SELECT ${sessionLineageColumns()}
+        FROM sessions
+        WHERE session_id = ?
+      `,
+    )
+    .get(sessionId);
+
+  if (row === undefined) {
+    return undefined;
+  }
+
+  return buildSessionLineageRow(
+    parseTypeBoxValue(
+      SESSION_LINEAGE_QUERY_ROW_SCHEMA,
+      row,
+      `Invalid session row for ${sessionId}`,
+    ),
+  );
+}
+
+export function getSessionByPath(
+  db: SessionIndexDatabase,
+  sessionPath: string,
+): SessionLineageRow | undefined {
+  const row = db
+    .prepare(
+      `
+        SELECT ${sessionLineageColumns()}
+        FROM sessions
+        WHERE session_path = ?
+      `,
+    )
+    .get(sessionPath);
+
+  if (row === undefined) {
+    return undefined;
+  }
+
+  return buildSessionLineageRow(
+    parseTypeBoxValue(
+      SESSION_LINEAGE_QUERY_ROW_SCHEMA,
+      row,
+      `Invalid session row for path ${sessionPath}`,
+    ),
+  );
+}
+
+export function getLineageSessions(
+  db: SessionIndexDatabase,
+  sessionId: string,
+): SessionRelatedSessionRow[] {
+  return queryRelatedSessions(db, sessionId);
+}
+
+export function getParentSession(
+  db: SessionIndexDatabase,
+  sessionId: string,
+): SessionLineageRow | undefined {
+  return queryRelatedSessions(db, sessionId, ["parent"])[0];
+}
+
+export function getAncestorSessions(
+  db: SessionIndexDatabase,
+  sessionId: string,
+): SessionLineageRow[] {
+  return queryRelatedSessions(db, sessionId, ["parent", "ancestor"]);
+}
+
+export function getChildSessions(db: SessionIndexDatabase, sessionId: string): SessionLineageRow[] {
+  return queryRelatedSessions(db, sessionId, ["child"]);
+}
+
+export function getSiblingSessions(
+  db: SessionIndexDatabase,
+  sessionId: string,
+): SessionLineageRow[] {
+  return queryRelatedSessions(db, sessionId, ["sibling"]);
+}
+
+export function rebuildSessionLineageRelations(db: SessionIndexDatabase): void {
+  db.prepare(`DELETE FROM session_lineage_relations`).run();
+
+  const rows = parseTypeBoxRows(
+    SESSION_GRAPH_ROW_SCHEMA,
+    db
+      .prepare(
+        `
+          SELECT
+            session_id as sessionId,
+            session_path as sessionPath,
+            parent_session_path as parentSessionPath,
+            parent_session_id as parentSessionId
+          FROM sessions
+        `,
+      )
+      .all(),
+    "Invalid session graph rows",
+  );
+
+  const pathToId = new Map(rows.map((row) => [row.sessionPath, row.sessionId]));
+  const nodes = new Map<string, SessionGraphNode>(
+    rows.map((row) => [
+      row.sessionId,
+      {
+        ...row,
+        resolvedParentSessionId:
+          row.parentSessionId ??
+          (row.parentSessionPath ? pathToId.get(row.parentSessionPath) : undefined),
+      },
+    ]),
+  );
+  const childrenByParent = new Map<string, string[]>();
+
+  for (const node of nodes.values()) {
+    if (!node.resolvedParentSessionId) {
+      continue;
+    }
+
+    const children = childrenByParent.get(node.resolvedParentSessionId) ?? [];
+    children.push(node.sessionId);
+    childrenByParent.set(node.resolvedParentSessionId, children);
+  }
+
+  const insertRelation = db.prepare(
+    `
+      INSERT INTO session_lineage_relations(session_id, related_session_id, relation, distance)
+      VALUES (?, ?, ?, ?)
+    `,
+  );
+
+  for (const node of nodes.values()) {
+    const relations = collectMaterializedLineageRows(node.sessionId, nodes, childrenByParent);
+    for (const relation of relations.values()) {
+      insertRelation.run(
+        relation.sessionId,
+        relation.relatedSessionId,
+        relation.relation,
+        relation.distance,
+      );
+    }
+  }
+}
+
+function queryRelatedSessions(
+  db: SessionIndexDatabase,
+  sessionId: string,
+  relations?: SessionLineageRelation[],
+): SessionRelatedSessionRow[] {
+  const relationFilter = relations?.length
+    ? ` AND r.relation IN (${relations.map(() => "?").join(", ")})`
+    : "";
+  const rows = parseTypeBoxRows(
+    SESSION_RELATED_QUERY_ROW_SCHEMA,
+    db
+      .prepare(
+        `
+          SELECT
+            ${sessionLineageColumns("s")},
+            r.relation as relation,
+            r.distance as distance
+          FROM session_lineage_relations r
+          JOIN sessions s ON s.session_id = r.related_session_id
+          WHERE r.session_id = ?${relationFilter}
+          ORDER BY
+            CASE r.relation
+              WHEN 'parent' THEN 1
+              WHEN 'child' THEN 2
+              WHEN 'sibling' THEN 3
+              WHEN 'ancestor' THEN 4
+              WHEN 'descendant' THEN 5
+              WHEN 'ancestor_sibling' THEN 6
+              ELSE 7
+            END ASC,
+            r.distance ASC,
+            s.modified_ts DESC
+        `,
+      )
+      .all(sessionId, ...(relations ?? [])),
+    `Invalid related session rows for ${sessionId}`,
+  );
+
+  return rows.map(buildRelatedSessionRow);
+}
+
+function collectMaterializedLineageRows(
+  sessionId: string,
+  nodes: Map<string, SessionGraphNode>,
+  childrenByParent: Map<string, string[]>,
+): Map<string, MaterializedLineageRow> {
+  const relations = new Map<string, MaterializedLineageRow>();
+  const visitedAncestors = new Set<string>();
+  const ancestors: Array<{ sessionId: string; distance: number }> = [];
+
+  let currentId = nodes.get(sessionId)?.resolvedParentSessionId;
+  let distance = 1;
+  while (currentId && !visitedAncestors.has(currentId)) {
+    visitedAncestors.add(currentId);
+    ancestors.push({ sessionId: currentId, distance });
+    setMaterializedLineageRow(relations, {
+      sessionId,
+      relatedSessionId: currentId,
+      relation: distance === 1 ? "parent" : "ancestor",
+      distance,
+    });
+    currentId = nodes.get(currentId)?.resolvedParentSessionId;
+    distance += 1;
+  }
+
+  const visitedDescendants = new Set<string>();
+  const queue = (childrenByParent.get(sessionId) ?? []).map((childId) => ({
+    childId,
+    distance: 1,
+  }));
+  while (queue.length > 0) {
+    const next = queue.shift();
+    if (!next || visitedDescendants.has(next.childId)) {
+      continue;
+    }
+
+    visitedDescendants.add(next.childId);
+    setMaterializedLineageRow(relations, {
+      sessionId,
+      relatedSessionId: next.childId,
+      relation: next.distance === 1 ? "child" : "descendant",
+      distance: next.distance,
+    });
+
+    for (const childId of childrenByParent.get(next.childId) ?? []) {
+      queue.push({ childId, distance: next.distance + 1 });
+    }
+  }
+
+  const parentId = nodes.get(sessionId)?.resolvedParentSessionId;
+  if (parentId) {
+    for (const siblingId of childrenByParent.get(parentId) ?? []) {
+      if (siblingId === sessionId) {
+        continue;
+      }
+
+      setMaterializedLineageRow(relations, {
+        sessionId,
+        relatedSessionId: siblingId,
+        relation: "sibling",
+        distance: 1,
+      });
+    }
+  }
+
+  for (const ancestor of ancestors) {
+    const ancestorParentId = nodes.get(ancestor.sessionId)?.resolvedParentSessionId;
+    if (!ancestorParentId) {
+      continue;
+    }
+
+    for (const siblingId of childrenByParent.get(ancestorParentId) ?? []) {
+      if (siblingId === ancestor.sessionId) {
+        continue;
+      }
+
+      setMaterializedLineageRow(relations, {
+        sessionId,
+        relatedSessionId: siblingId,
+        relation: "ancestor_sibling",
+        distance: ancestor.distance + 1,
+      });
+    }
+  }
+
+  return relations;
+}
+
+function setMaterializedLineageRow(
+  rows: Map<string, MaterializedLineageRow>,
+  candidate: MaterializedLineageRow,
+): void {
+  const existing = rows.get(candidate.relatedSessionId);
+  if (!existing) {
+    rows.set(candidate.relatedSessionId, candidate);
+    return;
+  }
+
+  const existingPriority = getLineageRelationPriority(existing.relation);
+  const candidatePriority = getLineageRelationPriority(candidate.relation);
+  if (candidatePriority < existingPriority) {
+    rows.set(candidate.relatedSessionId, candidate);
+    return;
+  }
+
+  if (candidatePriority === existingPriority && candidate.distance < existing.distance) {
+    rows.set(candidate.relatedSessionId, candidate);
+  }
+}
+
+function getLineageRelationPriority(relation: SessionLineageRelation): number {
+  switch (relation) {
+    case "parent":
+      return 1;
+    case "child":
+      return 2;
+    case "sibling":
+      return 3;
+    case "ancestor":
+      return 4;
+    case "descendant":
+      return 5;
+    case "ancestor_sibling":
+      return 6;
+  }
+}

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

@@ -0,0 +1,178 @@
+import { existsSync, mkdirSync } from "node:fs";
+import path from "node:path";
+import Database from "better-sqlite3";
+import { parseTypeBoxValue } from "../typebox.js";
+import {
+  INDEX_SCHEMA_VERSION,
+  METADATA_ROW_SCHEMA,
+  ROW_COUNT_SCHEMA,
+  type SessionIndexDatabase,
+  type SessionIndexStatus,
+} from "./common.js";
+
+export function ensureIndexDir(dir: string): string {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+
+export function createTempIndexPath(finalPath: string): string {
+  const dir = path.dirname(finalPath);
+  const baseName = path.basename(finalPath, path.extname(finalPath));
+  ensureIndexDir(dir);
+  return path.join(dir, `${baseName}.tmp-${process.pid}-${Date.now()}.sqlite`);
+}
+
+export function openIndexDatabase(
+  dbPath: string,
+  options?: { create?: boolean },
+): SessionIndexDatabase {
+  const create = options?.create ?? true;
+  const db = new Database(dbPath, { fileMustExist: !create });
+  db.pragma("journal_mode = WAL");
+  db.pragma("synchronous = NORMAL");
+  db.pragma("foreign_keys = ON");
+  return db;
+}
+
+export function initializeSchema(db: SessionIndexDatabase): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS metadata (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      session_id TEXT PRIMARY KEY,
+      session_path TEXT NOT NULL,
+      session_name TEXT NOT NULL,
+      first_user_prompt TEXT,
+      cwd TEXT NOT NULL,
+      repo_roots_json TEXT NOT NULL,
+      created_ts TEXT NOT NULL,
+      modified_ts TEXT NOT NULL,
+      message_count INTEGER NOT NULL,
+      entry_count INTEGER NOT NULL,
+      parent_session_path TEXT,
+      parent_session_id TEXT,
+      session_origin TEXT,
+      handoff_goal TEXT,
+      handoff_next_task TEXT,
+      index_version INTEGER NOT NULL,
+      indexed_at_ts TEXT NOT NULL,
+      index_source TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS sessions_modified_idx ON sessions(modified_ts DESC);
+    CREATE INDEX IF NOT EXISTS sessions_cwd_idx ON sessions(cwd);
+    CREATE INDEX IF NOT EXISTS sessions_path_idx ON sessions(session_path);
+    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_lineage_relations (
+      session_id TEXT NOT NULL,
+      related_session_id TEXT NOT NULL,
+      relation TEXT NOT NULL,
+      distance INTEGER NOT NULL,
+      PRIMARY KEY (session_id, related_session_id),
+      FOREIGN KEY (session_id) REFERENCES sessions(session_id) ON DELETE CASCADE,
+      FOREIGN KEY (related_session_id) REFERENCES sessions(session_id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS session_lineage_relations_related_idx
+      ON session_lineage_relations(related_session_id);
+    CREATE INDEX IF NOT EXISTS session_lineage_relations_relation_idx
+      ON session_lineage_relations(session_id, relation, distance);
+
+    CREATE TABLE IF NOT EXISTS session_text_chunks (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      entry_id TEXT,
+      entry_type TEXT NOT NULL,
+      role TEXT,
+      ts TEXT NOT NULL,
+      source_kind TEXT NOT NULL,
+      text TEXT NOT NULL,
+      FOREIGN KEY (session_id) REFERENCES sessions(session_id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS session_text_chunks_session_idx ON session_text_chunks(session_id);
+    CREATE INDEX IF NOT EXISTS session_text_chunks_ts_idx ON session_text_chunks(ts DESC);
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS session_text_chunks_fts USING fts5(
+      chunk_id UNINDEXED,
+      session_id UNINDEXED,
+      text
+    );
+
+    CREATE TABLE IF NOT EXISTS session_file_touches (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      entry_id TEXT,
+      op TEXT NOT NULL,
+      source TEXT NOT NULL,
+      raw_path TEXT NOT NULL,
+      abs_path TEXT,
+      cwd_rel_path TEXT,
+      repo_root TEXT,
+      repo_rel_path TEXT,
+      basename TEXT NOT NULL,
+      path_scope TEXT NOT NULL,
+      ts TEXT NOT NULL,
+      FOREIGN KEY (session_id) REFERENCES sessions(session_id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS session_file_touches_session_idx ON session_file_touches(session_id);
+    CREATE INDEX IF NOT EXISTS session_file_touches_op_idx ON session_file_touches(op);
+    CREATE INDEX IF NOT EXISTS session_file_touches_abs_idx ON session_file_touches(abs_path);
+    CREATE INDEX IF NOT EXISTS session_file_touches_repo_root_idx ON session_file_touches(repo_root);
+    CREATE INDEX IF NOT EXISTS session_file_touches_repo_rel_idx ON session_file_touches(repo_rel_path);
+    CREATE INDEX IF NOT EXISTS session_file_touches_cwd_rel_idx ON session_file_touches(cwd_rel_path);
+    CREATE INDEX IF NOT EXISTS session_file_touches_basename_idx ON session_file_touches(basename);
+  `);
+
+  setMetadata(db, "schema_version", String(INDEX_SCHEMA_VERSION));
+}
+
+export function setMetadata(db: SessionIndexDatabase, key: string, value: string): void {
+  db.prepare(
+    `INSERT INTO metadata(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value`,
+  ).run(key, value);
+}
+
+export function getMetadata(db: SessionIndexDatabase, key: string): string | undefined {
+  const row = db.prepare(`SELECT value FROM metadata WHERE key = ?`).get(key);
+  if (row === undefined) {
+    return undefined;
+  }
+
+  return parseTypeBoxValue(METADATA_ROW_SCHEMA, row, `Invalid metadata row for key ${key}`).value;
+}
+
+export function getIndexStatus(dbPath: string): SessionIndexStatus {
+  if (!existsSync(dbPath)) {
+    return { dbPath, exists: false };
+  }
+
+  const db = openIndexDatabase(dbPath, { create: false });
+  try {
+    const schemaVersionRaw = getMetadata(db, "schema_version");
+    const lastFullReindexAt = getMetadata(db, "indexed_at");
+    const sessionCountRow = parseTypeBoxValue(
+      ROW_COUNT_SCHEMA,
+      db.prepare(`SELECT COUNT(*) as count FROM sessions`).get(),
+      "Invalid session count row",
+    );
+
+    return {
+      dbPath,
+      exists: true,
+      schemaVersion: schemaVersionRaw ? Number(schemaVersionRaw) : undefined,
+      sessionCount: sessionCountRow.count,
+      lastFullReindexAt,
+    };
+  } finally {
+    db.close();
+  }
+}