pi-sessions 0.1.0

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

@@ -0,0 +1,173 @@
+import {
+  compactSessionId,
+  INDEX_SCHEMA_VERSION,
+  type SessionFileTouchRow,
+  type SessionIndexDatabase,
+  type SessionRow,
+  type SessionTextChunkRow,
+} from "./common.js";
+
+function sessionRowBindings(row: SessionRow, indexSource: string) {
+  return [
+    row.sessionId,
+    row.sessionPath,
+    row.sessionName,
+    row.firstUserPrompt ?? null,
+    row.cwd,
+    JSON.stringify(row.repoRoots),
+    row.startedAt,
+    row.modifiedAt,
+    row.messageCount,
+    row.entryCount,
+    row.parentSessionPath ?? null,
+    row.parentSessionId ?? null,
+    row.sessionOrigin ?? null,
+    row.handoffGoal ?? null,
+    row.handoffNextTask ?? null,
+    INDEX_SCHEMA_VERSION,
+    new Date().toISOString(),
+    indexSource,
+  ];
+}
+
+export function insertSession(
+  db: SessionIndexDatabase,
+  row: SessionRow,
+  indexSource: string,
+): void {
+  db.prepare(
+    `
+      INSERT INTO sessions(
+        session_id, session_path, session_name, first_user_prompt, cwd, repo_roots_json,
+        created_ts, modified_ts, message_count, entry_count,
+        parent_session_path, parent_session_id, session_origin,
+        handoff_goal, handoff_next_task,
+        index_version, indexed_at_ts, index_source
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `,
+  ).run(...sessionRowBindings(row, indexSource));
+  insertSessionIdChunk(db, row);
+}
+
+export function upsertSession(
+  db: SessionIndexDatabase,
+  row: SessionRow,
+  indexSource: string,
+): void {
+  db.prepare(
+    `
+      INSERT INTO sessions(
+        session_id, session_path, session_name, first_user_prompt, cwd, repo_roots_json,
+        created_ts, modified_ts, message_count, entry_count,
+        parent_session_path, parent_session_id, session_origin,
+        handoff_goal, handoff_next_task,
+        index_version, indexed_at_ts, index_source
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(session_id) DO UPDATE SET
+        session_path = excluded.session_path,
+        session_name = excluded.session_name,
+        first_user_prompt = excluded.first_user_prompt,
+        cwd = excluded.cwd,
+        repo_roots_json = excluded.repo_roots_json,
+        created_ts = excluded.created_ts,
+        modified_ts = excluded.modified_ts,
+        message_count = excluded.message_count,
+        entry_count = excluded.entry_count,
+        parent_session_path = excluded.parent_session_path,
+        parent_session_id = excluded.parent_session_id,
+        session_origin = excluded.session_origin,
+        handoff_goal = excluded.handoff_goal,
+        handoff_next_task = excluded.handoff_next_task,
+        index_version = excluded.index_version,
+        indexed_at_ts = excluded.indexed_at_ts,
+        index_source = excluded.index_source
+    `,
+  ).run(...sessionRowBindings(row, indexSource));
+  syncSessionIdChunk(db, row);
+}
+
+function insertSessionIdChunk(db: SessionIndexDatabase, row: SessionRow): void {
+  insertTextChunk(db, {
+    sessionId: row.sessionId,
+    entryType: "session_info",
+    ts: row.modifiedAt,
+    sourceKind: "session_id",
+    text: buildSessionIdSearchText(row.sessionId),
+  });
+}
+
+function syncSessionIdChunk(db: SessionIndexDatabase, row: SessionRow): void {
+  db.prepare(
+    `DELETE FROM session_text_chunks_fts
+     WHERE chunk_id IN (
+       SELECT CAST(id AS TEXT) FROM session_text_chunks
+       WHERE session_id = ? AND source_kind = 'session_id'
+     )`,
+  ).run(row.sessionId);
+
+  db.prepare(
+    `DELETE FROM session_text_chunks WHERE session_id = ? AND source_kind = 'session_id'`,
+  ).run(row.sessionId);
+
+  insertSessionIdChunk(db, row);
+}
+
+function buildSessionIdSearchText(sessionId: string): string {
+  const compact = compactSessionId(sessionId);
+  return compact === sessionId ? sessionId : `${sessionId} ${compact}`;
+}
+
+export function clearSessionIndexedData(db: SessionIndexDatabase, sessionId: string): void {
+  db.prepare(`DELETE FROM session_text_chunks_fts WHERE session_id = ?`).run(sessionId);
+  db.prepare(`DELETE FROM session_text_chunks WHERE session_id = ?`).run(sessionId);
+  db.prepare(`DELETE FROM session_file_touches WHERE session_id = ?`).run(sessionId);
+}
+
+export function insertTextChunk(db: SessionIndexDatabase, row: SessionTextChunkRow): void {
+  const result = db
+    .prepare(
+      `
+      INSERT INTO session_text_chunks(
+        session_id, entry_id, entry_type, role, ts, source_kind, text
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+    `,
+    )
+    .run(
+      row.sessionId,
+      row.entryId ?? null,
+      row.entryType,
+      row.role ?? null,
+      row.ts,
+      row.sourceKind,
+      row.text,
+    );
+
+  const chunkId = Number(result.lastInsertRowid);
+  db.prepare(
+    `INSERT INTO session_text_chunks_fts(chunk_id, session_id, text) VALUES (?, ?, ?)`,
+  ).run(chunkId, row.sessionId, row.text);
+}
+
+export function insertSessionFileTouch(db: SessionIndexDatabase, row: SessionFileTouchRow): void {
+  db.prepare(
+    `
+      INSERT INTO session_file_touches(
+        session_id, entry_id, op, source, raw_path, abs_path, cwd_rel_path,
+        repo_root, repo_rel_path, basename, path_scope, ts
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `,
+  ).run(
+    row.sessionId,
+    row.entryId ?? null,
+    row.op,
+    row.source,
+    row.rawPath,
+    row.absPath ?? null,
+    row.cwdRelPath ?? null,
+    row.repoRoot ?? null,
+    row.repoRelPath ?? null,
+    row.basename,
+    row.pathScope,
+    row.ts,
+  );
+}

package/extensions/shared/session-ui.ts

@@ -0,0 +1,15 @@
+export function isExactSessionId(value: string): boolean {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+
+export function shortenSessionId(sessionId: string): string {
+  return isExactSessionId(sessionId) ? sessionId.slice(0, 8) : sessionId;
+}
+
+export function formatSessionTitleOrShortId(
+  sessionName: string | undefined,
+  sessionId: string | undefined,
+): string {
+  const title = sessionName?.trim();
+  return title && title.length > 0 ? title : shortenSessionId(sessionId ?? "");
+}

package/extensions/shared/settings.ts

@@ -0,0 +1,141 @@
+import os from "node:os";
+import path from "node:path";
+import { getAgentDir, SettingsManager } from "@mariozechner/pi-coding-agent";
+import type { KeyId } from "@mariozechner/pi-tui";
+import { type Static, Type } from "@sinclair/typebox";
+import { parseTypeBoxValue } from "./typebox.js";
+
+export const DEFAULT_AUTO_TITLE_REFRESH_TURNS = 4;
+const SESSION_FILE_SETTINGS_SCHEMA = Type.Object({
+  handoff: Type.Optional(
+    Type.Object({
+      pickerShortcut: Type.Optional(Type.String()),
+    }),
+  ),
+  index: Type.Optional(
+    Type.Object({
+      dir: Type.Optional(Type.String()),
+    }),
+  ),
+  autoTitle: Type.Optional(
+    Type.Object({
+      refreshTurns: Type.Optional(Type.Integer({ minimum: 1 })),
+      model: Type.Optional(Type.String()),
+    }),
+  ),
+});
+const ROOT_SETTINGS_SCHEMA = Type.Object({
+  sessions: Type.Optional(SESSION_FILE_SETTINGS_SCHEMA),
+});
+
+export class ModelReference {
+  constructor(
+    readonly provider: string,
+    readonly modelId: string,
+  ) {}
+
+  toString(): string {
+    return `${this.provider}/${this.modelId}`;
+  }
+}
+
+export interface AutoTitleSettings {
+  refreshTurns: number;
+  model: ModelReference | undefined;
+}
+
+export interface SessionSettings {
+  handoff: {
+    pickerShortcut: KeyId;
+  };
+  index: {
+    path: string;
+  };
+  autoTitle: AutoTitleSettings;
+}
+
+type SessionFileSettings = Static<typeof SESSION_FILE_SETTINGS_SCHEMA>;
+
+export function getDefaultIndexDir(): string {
+  return path.join(os.homedir(), ".pi", "agent", "pi-sessions");
+}
+
+export function getDefaultIndexPath(): string {
+  return path.join(getDefaultIndexDir(), "index.sqlite");
+}
+
+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 normalizeIndexDir(value: string | undefined): string {
+  if (value === undefined) {
+    return getDefaultIndexDir();
+  }
+
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return getDefaultIndexDir();
+  }
+
+  const expanded = expandHome(trimmed);
+  if (!path.isAbsolute(expanded)) {
+    throw new Error('sessions.index.dir must be an absolute path or start with "~/".');
+  }
+
+  return path.normalize(expanded);
+}
+
+function normalizePickerShortcut(value: string | undefined): KeyId {
+  const trimmed = value?.trim();
+  return (trimmed ? trimmed : "alt+o") as KeyId;
+}
+
+function parseModelReference(value: string | undefined): ModelReference | undefined {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+
+  const slashIndex = trimmed.indexOf("/");
+  if (slashIndex <= 0 || slashIndex === trimmed.length - 1) {
+    return undefined;
+  }
+
+  return new ModelReference(trimmed.slice(0, slashIndex), trimmed.slice(slashIndex + 1));
+}
+
+function loadSessionFileSettings(): SessionFileSettings {
+  const globalSettings = SettingsManager.create(undefined, getAgentDir()).getGlobalSettings();
+  const parsed = parseTypeBoxValue(ROOT_SETTINGS_SCHEMA, globalSettings, "Invalid settings");
+  return parsed.sessions ?? {};
+}
+
+function resolveSessionSettings(fileSettings: SessionFileSettings): SessionSettings {
+  const indexDir = normalizeIndexDir(fileSettings.index?.dir);
+
+  return {
+    handoff: {
+      pickerShortcut: normalizePickerShortcut(fileSettings.handoff?.pickerShortcut),
+    },
+    index: {
+      path: path.join(indexDir, "index.sqlite"),
+    },
+    autoTitle: {
+      refreshTurns: fileSettings.autoTitle?.refreshTurns ?? DEFAULT_AUTO_TITLE_REFRESH_TURNS,
+      model: parseModelReference(fileSettings.autoTitle?.model),
+    },
+  };
+}
+
+export function loadSettings(): SessionSettings {
+  return resolveSessionSettings(loadSessionFileSettings());
+}

package/extensions/shared/time.ts

@@ -0,0 +1,38 @@
+const RELATIVE_TIME_FORMATTER = new Intl.RelativeTimeFormat("en", {
+  numeric: "always",
+  style: "narrow",
+});
+
+const RELATIVE_TIME_UNITS = [
+  ["year", 60 * 60 * 24 * 365],
+  ["month", 60 * 60 * 24 * 30],
+  ["week", 60 * 60 * 24 * 7],
+  ["day", 60 * 60 * 24],
+  ["hour", 60 * 60],
+  ["minute", 60],
+  ["second", 1],
+] as const;
+
+export function formatCompactRelativeTime(
+  value: string | number | Date,
+  nowMs: number = Date.now(),
+): string | undefined {
+  const targetMs =
+    value instanceof Date ? value.getTime() : typeof value === "string" ? Date.parse(value) : value;
+  if (Number.isNaN(targetMs)) {
+    return undefined;
+  }
+
+  const diffSeconds = Math.round((targetMs - nowMs) / 1000);
+  const absDiffSeconds = Math.abs(diffSeconds);
+  if (absDiffSeconds < 60) {
+    return "now";
+  }
+
+  for (const [unit, secondsPerUnit] of RELATIVE_TIME_UNITS) {
+    if (absDiffSeconds >= secondsPerUnit || unit === "second") {
+      const valueForUnit = Math.sign(diffSeconds) * Math.floor(absDiffSeconds / secondsPerUnit);
+      return RELATIVE_TIME_FORMATTER.format(valueForUnit, unit).replace(/ ago$/, "");
+    }
+  }
+}

package/extensions/shared/typebox.ts

@@ -0,0 +1,61 @@
+import type { Static, TSchema } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+
+export function isTypeBoxValue<T extends TSchema>(schema: T, value: unknown): value is Static<T> {
+  return Value.Check(schema, value);
+}
+
+export function parseTypeBoxValue<T extends TSchema>(
+  schema: T,
+  value: unknown,
+  context: string,
+): Static<T> {
+  if (Value.Check(schema, value)) {
+    return value as Static<T>;
+  }
+
+  throw new Error(formatTypeBoxError(schema, value, context));
+}
+
+export function safeParseTypeBoxValue<T extends TSchema>(
+  schema: T,
+  value: unknown,
+): Static<T> | undefined {
+  return Value.Check(schema, value) ? (value as Static<T>) : undefined;
+}
+
+export function parseTypeBoxRows<T extends TSchema>(
+  schema: T,
+  value: unknown,
+  context: string,
+): Static<T>[] {
+  if (!Array.isArray(value)) {
+    throw new Error(`${context}: expected an array of rows.`);
+  }
+
+  return value.map((row, index) =>
+    parseTypeBoxValue(schema, row, `${context} at row ${index + 1}`),
+  );
+}
+
+export function safeParseTypeBoxJson<T extends TSchema>(
+  schema: T,
+  raw: string,
+): Static<T> | undefined {
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    return safeParseTypeBoxValue(schema, parsed);
+  } catch {
+    return undefined;
+  }
+}
+
+function formatTypeBoxError(schema: TSchema, value: unknown, context: string): string {
+  const firstError = Value.Errors(schema, value).First();
+  if (!firstError) {
+    return `${context}: invalid value.`;
+  }
+
+  const path = firstError.path.length > 0 ? firstError.path : "/";
+  return `${context}: ${path} ${firstError.message}`;
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "pi-sessions",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Pi session search, ask, handoff, auto-titling, and indexing tools",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thurstonsand/pi-sessions.git"
+  },
+  "homepage": "https://github.com/thurstonsand/pi-sessions#readme",
+  "bugs": {
+    "url": "https://github.com/thurstonsand/pi-sessions/issues"
+  },
+  "keywords": [
+    "pi-package"
+  ],
+  "files": [
+    "extensions",
+    "images"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions/session-ask.ts",
+      "./extensions/session-auto-title.ts",
+      "./extensions/session-handoff.ts",
+      "./extensions/session-hooks.ts",
+      "./extensions/session-index.ts",
+      "./extensions/session-search.ts"
+    ]
+  },
+  "scripts": {
+    "lint": "biome check .",
+    "format": "biome format --write .",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "check": "biome check . && tsc --noEmit && vitest run",
+    "prepare": "husky"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.11",
+    "@mariozechner/pi-ai": "^0.66.1",
+    "@mariozechner/pi-coding-agent": "^0.66.1",
+    "@mariozechner/pi-tui": "^0.66.1",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.6.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.4.0",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.4"
+  },
+  "dependencies": {
+    "better-sqlite3": "^12.8.0"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-ai": ">=0.66.1",
+    "@mariozechner/pi-coding-agent": ">=0.66.1",
+    "@mariozechner/pi-tui": ">=0.66.1",
+    "@sinclair/typebox": ">=0.34.49"
+  },
+  "lint-staged": {
+    "*.{js,cjs,mjs,jsx,ts,tsx,json,jsonc}": "biome check --write --no-errors-on-unmatched"
+  }
+}