pi-session-search 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sam Foy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,84 @@
+# pi-session-search
+
+Index, summarize, and search past [pi](https://github.com/badlogic/pi-mono) coding sessions. Provides semantic search across your entire session history — both active and archived sessions.
+
+## Features
+
+- **Semantic search** — Find past sessions by topic, not just keywords (`session_search`)
+- **Browse & filter** — List sessions by project, date range, archive status (`session_list`)
+- **Read conversations** — View the full conversation from any past session (`session_read`)
+- **Auto-indexing** — Parses JSONL session files on startup, tracks changes incrementally
+- **Archive support** — Indexes both `~/.pi/agent/sessions/` and `~/.pi/agent/sessions-archive/`
+- **Multiple embedders** — OpenAI, AWS Bedrock, or local Ollama
+
+## Install
+
+```bash
+pi install pi-session-search
+```
+
+Or add to `~/.pi/agent/settings.json`:
+
+```json
+{
+  "packages": ["npm:pi-session-search"]
+}
+```
+
+## Setup
+
+Run `/session-search-setup` in pi to configure the embedding provider:
+
+- **OpenAI** — Uses `text-embedding-3-small` (needs `OPENAI_API_KEY`)
+- **Bedrock** — Uses Titan Embeddings v2 (needs AWS credentials)
+- **Ollama** — Uses `nomic-embed-text` (needs local Ollama running)
+
+Config is stored at `~/.pi/session-search/config.json`.
+
+## Usage
+
+### Semantic search
+```
+session_search(query="how did we debug the Lambda timeout")
+session_search(query="CI pipeline configuration", limit=5)
+```
+
+### Browse sessions
+```
+session_list(project="Rosie", after="2026-03-01")
+session_list(archived=true, limit=20)
+```
+
+### Read a session
+```
+session_read(session="<file-path-or-uuid>")
+session_read(session="<id>", offset=50, limit=50)
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/session-search-setup` | Configure embedding provider |
+| `/session-reindex` | Force full re-index of all sessions |
+
+## How It Works
+
+1. On startup, discovers all `.jsonl` session files in `~/.pi/agent/sessions/` (and `~/.pi/agent/sessions-archive/` if it exists)
+2. Parses each session to extract: user messages, assistant text, tool calls, files modified, models used, compaction summaries
+3. Generates a summary and embedding for each session
+4. Stores the index at `~/.pi/session-search/index/`
+5. On subsequent startups, only re-indexes new or changed sessions
+6. Re-syncs in the background every 5 minutes to pick up new sessions
+
+You can also configure extra session/archive directories during setup if you store sessions in non-default locations.
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `OPENAI_API_KEY` | Required for OpenAI embedder |
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "pi-session-search",
+  "version": "0.1.0",
+  "description": "Index, summarize, and search past pi sessions. Covers both active and archived sessions, enabling semantic search and introspection over your coding history.",
+  "keywords": [
+    "pi-package",
+    "extension",
+    "session",
+    "search",
+    "semantic-search",
+    "embeddings"
+  ],
+  "files": [
+    "src",
+    "skills",
+    "README.md",
+    "LICENSE"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/samfoy/pi-session-search"
+  },
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "*",
+    "@sinclair/typebox": "*"
+  },
+  "optionalDependencies": {
+    "@aws-sdk/client-bedrock-runtime": "^3.700.0",
+    "@aws-sdk/credential-providers": "^3.700.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0"
+  }
+}

package/skills/session-history/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: session-history
+description: Search, browse, and read past pi coding sessions. Use when the user asks about previous work, past decisions, what was done before, or wants to find a specific session. Covers both active and archived sessions.
+---
+
+# Session History
+
+Search, browse, and introspect on past pi coding sessions — including archived ones.
+
+## Available Tools
+
+This skill provides three tools:
+
+### session_search
+Semantic search across all indexed sessions. Use for finding sessions by topic, technology, or intent.
+
+```
+session_search(query="refactoring the auth module")
+session_search(query="Lambda timeout debugging", limit=5)
+session_search(query="setting up CI pipeline for Nessie")
+```
+
+### session_list
+Browse sessions with filters. Good for time-based queries or project-specific browsing.
+
+```
+session_list(project="Rosie")                    # Sessions in the Rosie project
+session_list(after="2026-03-01", limit=10)       # Recent sessions
+session_list(archived=true, limit=20)            # Archived sessions only
+session_list(project="pi-slack-bot", after="2026-03-10")
+```
+
+### session_read
+Read the full conversation from a specific session. Use the file path or UUID from search/list results.
+
+```
+session_read(session="~/.pi/agent/sessions/--workplace-samfp-Rosie--/2026-03-10T21-36-44.jsonl")
+session_read(session="124c2fe2-820c-4d63-8899-eb8d48007d39")
+session_read(session="...", offset=50, limit=50)           # Pagination for long sessions
+session_read(session="...", include_tools=true)             # Include tool call results
+```
+
+## Workflow
+
+1. **Find sessions**: Use `session_search` for semantic queries or `session_list` for browsing
+2. **Read details**: Use `session_read` with the file path from results to see the full conversation
+3. **Extract context**: Use information from past sessions to inform current work
+
+## Setup
+
+If not yet configured, run `/session-search-setup` to choose an embedding provider (OpenAI, Bedrock, or Ollama).
+
+To force a full re-index, run `/session-reindex`.
+
+## What Gets Indexed
+
+- All active sessions from `~/.pi/agent/sessions/`
+- All archived sessions from `~/.pi/agent/sessions-archive/`
+- User messages, assistant responses, tool usage patterns
+- Compaction summaries (condensed session context)
+- Files read/modified, models used, project directories
+
+## Tips
+
+- Session search is best for "when did we...", "how did we handle...", "what approach did we use for..." queries
+- Session list is best for "show me recent sessions", "what did we work on in project X" queries
+- For very long sessions, use `session_read` with pagination (`offset`/`limit`)
+- Set `include_tools=true` on `session_read` when you need to see the actual tool outputs (verbose)

package/src/config.ts

@@ -0,0 +1,54 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import type { EmbedderConfig } from "./embedder";
+
+// ─── Types ───────────────────────────────────────────────────────────
+
+export interface Config {
+  /** Extra session directories to scan (in addition to default) */
+  extraSessionDirs: string[];
+  /** Extra archive directories to scan (in addition to default) */
+  extraArchiveDirs: string[];
+  /** Embedder configuration */
+  embedder: EmbedderConfig;
+}
+
+export interface ConfigFile {
+  extraSessionDirs?: string[];
+  extraArchiveDirs?: string[];
+  embedder: EmbedderConfig;
+}
+
+// ─── Paths ───────────────────────────────────────────────────────────
+
+const CONFIG_DIR = join(process.env.HOME || "~", ".pi", "session-search");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+const INDEX_DIR = join(CONFIG_DIR, "index");
+
+export function getConfigPath(): string {
+  return CONFIG_FILE;
+}
+
+export function getIndexDir(): string {
+  return INDEX_DIR;
+}
+
+// ─── Load / Save ─────────────────────────────────────────────────────
+
+export function loadConfig(): Config | null {
+  if (!existsSync(CONFIG_FILE)) return null;
+
+  const raw = readFileSync(CONFIG_FILE, "utf8");
+  const file = JSON.parse(raw) as ConfigFile;
+
+  return {
+    extraSessionDirs: file.extraSessionDirs ?? [],
+    extraArchiveDirs: file.extraArchiveDirs ?? [],
+    embedder: file.embedder,
+  };
+}
+
+export function saveConfig(file: ConfigFile): void {
+  mkdirSync(dirname(CONFIG_FILE), { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(file, null, 2), "utf8");
+}

package/src/embedder.ts

@@ -0,0 +1,251 @@
+/**
+ * Embedding interface + factory. Reuses the same provider patterns as
+ * pi-knowledge-search but lives in this package to avoid a hard dependency.
+ */
+
+export interface Embedder {
+  embed(text: string, signal?: AbortSignal): Promise<number[]>;
+  embedBatch(
+    texts: string[],
+    signal?: AbortSignal
+  ): Promise<(number[] | null)[]>;
+}
+
+export interface EmbedderConfig {
+  type: "openai" | "bedrock" | "ollama";
+  // OpenAI
+  apiKey?: string;
+  model?: string;
+  // Bedrock
+  profile?: string;
+  region?: string;
+  // Ollama
+  url?: string;
+  // Shared
+  dimensions?: number;
+}
+
+const DEFAULTS: Record<string, Partial<EmbedderConfig>> = {
+  openai: { model: "text-embedding-3-small", dimensions: 512 },
+  bedrock: {
+    model: "amazon.titan-embed-text-v2:0",
+    region: "us-east-1",
+    profile: "default",
+    dimensions: 512,
+  },
+  ollama: { model: "nomic-embed-text", url: "http://localhost:11434" },
+};
+
+export function createEmbedder(config: EmbedderConfig): Embedder {
+  const defaults = DEFAULTS[config.type] ?? {};
+  const merged = { ...defaults, ...config };
+
+  switch (merged.type) {
+    case "openai":
+      return new OpenAIEmbedder(
+        merged.apiKey || process.env.OPENAI_API_KEY || "",
+        merged.model!,
+        merged.dimensions!
+      );
+    case "bedrock":
+      return new BedrockEmbedder(
+        merged.profile!,
+        merged.region!,
+        merged.model!,
+        merged.dimensions!
+      );
+    case "ollama":
+      return new OllamaEmbedder(merged.url!, merged.model!);
+    default:
+      throw new Error(`Unknown embedder type: ${merged.type}`);
+  }
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────
+
+function truncate(text: string, maxChars = 12000): string {
+  return text.length > maxChars ? text.slice(0, maxChars) : text;
+}
+
+async function parallelMap<T, R>(
+  items: T[],
+  fn: (item: T) => Promise<R>,
+  concurrency: number,
+  signal?: AbortSignal
+): Promise<R[]> {
+  const results: R[] = new Array(items.length);
+  let cursor = 0;
+  const worker = async () => {
+    while (cursor < items.length) {
+      if (signal?.aborted) throw new Error("Aborted");
+      const idx = cursor++;
+      results[idx] = await fn(items[idx]);
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, items.length) }, () => worker())
+  );
+  return results;
+}
+
+// ─── OpenAI ──────────────────────────────────────────────────────────
+
+class OpenAIEmbedder implements Embedder {
+  constructor(
+    private apiKey: string,
+    private model: string,
+    private dimensions: number
+  ) {}
+
+  async embed(text: string, signal?: AbortSignal): Promise<number[]> {
+    const [result] = await this.embedBatch([text], signal);
+    if (!result) throw new Error("Embedding failed");
+    return result;
+  }
+
+  async embedBatch(
+    texts: string[],
+    signal?: AbortSignal
+  ): Promise<(number[] | null)[]> {
+    const BATCH = 100;
+    const results: (number[] | null)[] = new Array(texts.length).fill(null);
+
+    for (let i = 0; i < texts.length; i += BATCH) {
+      if (signal?.aborted) throw new Error("Aborted");
+      const batch = texts.slice(i, i + BATCH).map((t) => truncate(t));
+
+      const res = await fetch("https://api.openai.com/v1/embeddings", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          input: batch,
+          model: this.model,
+          dimensions: this.dimensions,
+        }),
+        signal,
+      });
+
+      if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`OpenAI ${res.status}: ${body.slice(0, 200)}`);
+      }
+
+      const json = (await res.json()) as {
+        data: { embedding: number[]; index: number }[];
+      };
+      for (const item of json.data) {
+        results[i + item.index] = item.embedding;
+      }
+    }
+    return results;
+  }
+}
+
+// ─── Bedrock ─────────────────────────────────────────────────────────
+
+class BedrockEmbedder implements Embedder {
+  private clientPromise: Promise<any>;
+
+  constructor(
+    profile: string,
+    region: string,
+    private model: string,
+    private dimensions: number
+  ) {
+    this.clientPromise = (async () => {
+      const { BedrockRuntimeClient } = await import(
+        "@aws-sdk/client-bedrock-runtime"
+      );
+      const { fromIni } = await import("@aws-sdk/credential-providers");
+      return new BedrockRuntimeClient({
+        region,
+        credentials: fromIni({ profile }),
+      });
+    })();
+  }
+
+  async embed(text: string, signal?: AbortSignal): Promise<number[]> {
+    const [result] = await this.embedBatch([text], signal);
+    if (!result) throw new Error("Embedding failed");
+    return result;
+  }
+
+  async embedBatch(
+    texts: string[],
+    signal?: AbortSignal
+  ): Promise<(number[] | null)[]> {
+    const client = await this.clientPromise;
+    return parallelMap(
+      texts,
+      async (text) => {
+        const { InvokeModelCommand } = await import(
+          "@aws-sdk/client-bedrock-runtime"
+        );
+        const body = JSON.stringify({
+          inputText: truncate(text),
+          dimensions: this.dimensions,
+          normalize: true,
+        });
+        const cmd = new InvokeModelCommand({
+          modelId: this.model,
+          contentType: "application/json",
+          accept: "application/json",
+          body: new TextEncoder().encode(body),
+        });
+        const res = await client.send(cmd);
+        const parsed = JSON.parse(new TextDecoder().decode(res.body));
+        if (!parsed.embedding) throw new Error("No embedding in response");
+        return parsed.embedding;
+      },
+      10,
+      signal
+    );
+  }
+}
+
+// ─── Ollama ──────────────────────────────────────────────────────────
+
+class OllamaEmbedder implements Embedder {
+  constructor(
+    private url: string,
+    private model: string
+  ) {
+    this.url = url.replace(/\/$/, "");
+  }
+
+  async embed(text: string, signal?: AbortSignal): Promise<number[]> {
+    const res = await fetch(`${this.url}/api/embed`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model: this.model, input: truncate(text) }),
+      signal,
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`Ollama ${res.status}: ${body.slice(0, 200)}`);
+    }
+    const json = (await res.json()) as { embeddings: number[][] };
+    return json.embeddings[0];
+  }
+
+  async embedBatch(
+    texts: string[],
+    signal?: AbortSignal
+  ): Promise<(number[] | null)[]> {
+    return parallelMap(
+      texts,
+      async (text) => {
+        try {
+          return await this.embed(text, signal);
+        } catch {
+          return null;
+        }
+      },
+      4,
+      signal
+    );
+  }
+}