@chendpoc/pi-memory 0.1.0 → 0.1.12

package/src/fallback/sessionSearch.ts

@@ -16,10 +16,6 @@ export interface SessionSearchHit {
 let cachedIndex: SessionIndex | null = null;
 let cachedDbPath: string | null = null;
 
-/**
- * Get or open the FTS5 session index. Returns null if better-sqlite3
- * is unavailable or the DB file doesn't exist.
- */
 function getSessionIndex(dbPath: string): SessionIndex | null {
   if (cachedIndex && cachedDbPath === dbPath) return cachedIndex;
   if (!fsSync.existsSync(dbPath)) return null;
@@ -47,8 +43,29 @@ interface PiSessionFile {
 
 const SNIPPET_MAX = 240;
 
+async function collectFiles(dir: string): Promise<string[]> {
+  let names: string[];
+  try {
+    names = await fs.readdir(dir);
+  } catch {
+    return [];
+  }
+  const files: string[] = [];
+  for (const name of names) {
+    const full = path.join(dir, name);
+    let st;
+    try { st = await fs.stat(full); } catch { continue; }
+    if (st.isDirectory()) {
+      files.push(...await collectFiles(full));
+    } else if (st.isFile() && (name.endsWith(".json") || name.endsWith(".jsonl"))) {
+      files.push(full);
+    }
+  }
+  return files;
+}
+
 /**
- * Keyword search over Pi-style session JSON files (one directory level).
+ * Keyword search over Pi-style session files (JSON + JSONL, recursive subdirectories).
  * Uses FTS5 index when available, falls back to file scan.
  * All whitespace-separated terms must match (case-insensitive AND).
  */
@@ -72,17 +89,10 @@ export async function sessionKeywordSearch(
   const terms = splitTerms(q);
   if (terms.length === 0) return [];
 
-  let entries: string[];
-  try {
-    entries = await fs.readdir(sessionsDir);
-  } catch {
-    return [];
-  }
-
+  const filePaths = await collectFiles(sessionsDir);
   const hits: SessionSearchHit[] = [];
-  for (const name of entries) {
-    if (!name.endsWith(".json")) continue;
-    const filePath = path.join(sessionsDir, name);
+
+  for (const filePath of filePaths) {
     let st;
     try {
       st = await fs.stat(filePath);
@@ -91,34 +101,104 @@ export async function sessionKeywordSearch(
     }
     if (!st.isFile()) continue;
 
-    let session: PiSessionFile;
+    let raw: string;
+    try {
+      raw = await fs.readFile(filePath, "utf8");
+    } catch {
+      continue;
+    }
+
+    if (filePath.endsWith(".jsonl")) {
+      scanJsonlFile(raw, filePath, terms, hits, limit);
+    } else {
+      scanJsonFile(raw, filePath, terms, hits, limit);
+    }
+
+    if (hits.length >= limit) return hits;
+  }
+  return hits;
+}
+
+function scanJsonFile(
+  raw: string,
+  filePath: string,
+  terms: string[],
+  hits: SessionSearchHit[],
+  limit: number,
+): void {
+  let session: PiSessionFile;
+  try {
+    session = JSON.parse(raw) as PiSessionFile;
+  } catch {
+    return;
+  }
+
+  const sessionId = session.id ?? path.basename(filePath, ".json");
+  const title = session.title ?? "";
+  const createdAt = session.created_at ?? "";
+
+  for (let i = 0; i < (session.messages?.length ?? 0); i++) {
+    const msg = session.messages![i]!;
+    const text = messageText(msg.content);
+    if (!text || !allTermsMatch(text, terms)) continue;
+    hits.push({
+      session_id: sessionId,
+      session_title: title,
+      role: msg.role ?? "unknown",
+      snippet: makeSnippet(text, terms[0]!),
+      msg_index: i,
+      created_at: createdAt,
+    });
+    if (hits.length >= limit) return;
+  }
+}
+
+function scanJsonlFile(
+  raw: string,
+  filePath: string,
+  terms: string[],
+  hits: SessionSearchHit[],
+  limit: number,
+): void {
+  const lines = raw.split("\n").filter((l) => l.trim());
+  let sessionId = path.basename(filePath, ".jsonl");
+  let title = "";
+  let createdAt = "";
+  let msgIndex = 0;
+
+  for (const line of lines) {
+    let obj: Record<string, unknown>;
     try {
-      const raw = await fs.readFile(filePath, "utf8");
-      session = JSON.parse(raw) as PiSessionFile;
+      obj = JSON.parse(line) as Record<string, unknown>;
     } catch {
       continue;
     }
 
-    const sessionId = session.id ?? path.basename(name, ".json");
-    const title = session.title ?? "";
-    const createdAt = session.created_at ?? "";
+    if (obj.type === "session") {
+      sessionId = (obj.id as string) ?? sessionId;
+      title = (obj.title as string) ?? "";
+      createdAt = (obj.timestamp as string) ?? "";
+      continue;
+    }
 
-    for (let i = 0; i < (session.messages?.length ?? 0); i++) {
-      const msg = session.messages![i]!;
+    if (obj.type === "message") {
+      const msg = (obj as { message?: PiSessionMessage }).message;
+      if (!msg?.role || !msg.content) continue;
+      if (msg.role !== "user" && msg.role !== "assistant") continue;
       const text = messageText(msg.content);
       if (!text || !allTermsMatch(text, terms)) continue;
       hits.push({
         session_id: sessionId,
         session_title: title,
-        role: msg.role ?? "unknown",
+        role: msg.role,
         snippet: makeSnippet(text, terms[0]!),
-        msg_index: i,
+        msg_index: msgIndex,
         created_at: createdAt,
       });
-      if (hits.length >= limit) return hits;
+      msgIndex++;
+      if (hits.length >= limit) return;
     }
   }
-  return hits;
 }
 
 function splitTerms(query: string): string[] {

package/src/index.ts

@@ -25,6 +25,15 @@ export {
   type MemoryProvider,
 } from "./config.js";
 
+export {
+  defaultMemoryConfigPath,
+  loadMemoryConfig,
+  loadMemorySettings,
+  resolveHelperModelSpec,
+  type LoadedMemorySettings,
+  type MemorySettingsFile,
+} from "./settings.js";
+
 export {
   defaultBundleRoot,
   defaultPiHome,
@@ -88,10 +97,12 @@ export {
 
 export {
   PRIVATE_MEMORY_BODY_BYTE_CAP,
+  SEMANTIC_FALLBACK_CANDIDATES,
   renderFallbackPrivateMemory,
   renderPrivateMemoryContext,
   sanitizeUserBlock,
   truncatePrivateMemoryBody,
+  type FallbackRenderOptions,
   type PreflightQueryResult,
 } from "./preflight/render.js";
 
@@ -206,6 +217,23 @@ export {
 
 export { defaultSessionDbPath } from "./fallback/sessionSearch.js";
 
+export { LocalGraphQuerier } from "./local/graphQuery.js";
+
+export {
+  createOllamaLLMClient,
+  createOllamaMemoryHelper,
+  ollamaHealthCheck,
+  DEFAULT_OLLAMA_CONFIG,
+  type OllamaConfig,
+} from "./adapters/ollamaClient.js";
+
+export {
+  createOpenAICompatLLMClient,
+  createOpenAICompatMemoryHelper,
+  openaiCompatHealthCheck,
+  type OpenAICompatConfig,
+} from "./adapters/openaiCompatClient.js";
+
 export {
   rerankWithLLM,
   type RerankOptions,

package/src/local/graphQuery.ts

@@ -0,0 +1,252 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import type {
+  ErrorClass,
+  MemoryBlock,
+  MemoryCandidateGroup,
+  QueryCandidate,
+  QueryIntent,
+  ResponseEnvelope,
+} from "../types.js";
+
+interface BundleEntity {
+  entity_id: string;
+  label: string;
+  type: string;
+  aliases: string[];
+  mention_count: number;
+  distinct_session_count: number;
+}
+
+interface BundleEdge {
+  head_entity_id: string;
+  relation: string;
+  tail_entity_id: string;
+  supporting_event_ids: string[];
+  evidence: string;
+}
+
+interface BundleEvent {
+  event_id: string;
+  description: string;
+  session_id: string;
+  timestamp: string;
+}
+
+interface GraphData {
+  entities: BundleEntity[];
+  edges: BundleEdge[];
+  events: BundleEvent[];
+}
+
+export class LocalGraphQuerier {
+  private entities: BundleEntity[] = [];
+  private edges: BundleEdge[] = [];
+  private events: BundleEvent[] = [];
+  private entityById = new Map<string, BundleEntity>();
+  private entityByLabel = new Map<string, BundleEntity>();
+  private loaded = false;
+  private graphMtime = 0;
+
+  constructor(private readonly bundleRoot: string) {}
+
+  load(): boolean {
+    const graphPath = path.join(this.bundleRoot, "current", "graph.json");
+    try {
+      const raw = fs.readFileSync(graphPath, "utf8");
+      const data = JSON.parse(raw) as GraphData;
+      this.entities = data.entities ?? [];
+      this.edges = data.edges ?? [];
+      this.events = data.events ?? [];
+
+      this.entityById.clear();
+      this.entityByLabel.clear();
+      for (const e of this.entities) {
+        this.entityById.set(e.entity_id, e);
+        this.entityByLabel.set(e.label.toLowerCase(), e);
+        for (const alias of e.aliases) {
+          this.entityByLabel.set(alias.toLowerCase(), e);
+        }
+      }
+      this.graphMtime = fs.statSync(graphPath).mtimeMs;
+      this.loaded = true;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  isLoaded(): boolean {
+    return this.loaded;
+  }
+
+  /**
+   * Returns true when the on-disk graph.json has changed since the last load().
+   * Always returns false when not yet loaded.
+   */
+  isStale(): boolean {
+    if (!this.loaded) return false;
+    const graphPath = path.join(this.bundleRoot, "current", "graph.json");
+    try {
+      return fs.statSync(graphPath).mtimeMs !== this.graphMtime;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Re-loads from disk if isStale(). Returns true when a reload actually happened.
+   */
+  reloadIfStale(): boolean {
+    if (!this.isStale()) return false;
+    return this.load();
+  }
+
+  private findEntity(mention: string): BundleEntity | null {
+    const key = mention.toLowerCase().trim();
+    return this.entityByLabel.get(key) ?? null;
+  }
+
+  private findEntities(mentions: string[]): BundleEntity[] {
+    const found: BundleEntity[] = [];
+    for (const m of mentions) {
+      const e = this.findEntity(m);
+      if (e) found.push(e);
+    }
+    return found;
+  }
+
+  query(intent: QueryIntent): {
+    env: ResponseEnvelope | null;
+    errorClass: ErrorClass;
+  } {
+    if (!this.loaded) {
+      return { env: null, errorClass: "unavailable" };
+    }
+
+    const anchors = this.findEntities(intent.anchor_mentions);
+    if (anchors.length === 0) {
+      return {
+        env: this.makeEnvelope(intent, [], [], "no matching entities found"),
+        errorClass: "ok",
+      };
+    }
+
+    const limit = intent.result_limit && intent.result_limit > 0 ? intent.result_limit : 10;
+    const candidates: QueryCandidate[] = [];
+    const groups: MemoryCandidateGroup[] = [];
+
+    for (const anchor of anchors) {
+      const relatedEdges = this.edges.filter((e) => {
+        const matchesHead = e.head_entity_id === anchor.entity_id;
+        const matchesTail = e.tail_entity_id === anchor.entity_id;
+        if (!matchesHead && !matchesTail) return false;
+
+        if (intent.relation_constraints?.length) {
+          return intent.relation_constraints.some((rc) => {
+            const clean = rc.replace(/\^-1$/, "").replace(/^\^/, "");
+            return e.relation === clean;
+          });
+        }
+        return true;
+      });
+
+      for (const edge of relatedEdges) {
+        if (candidates.length >= limit) break;
+        const isHead = edge.head_entity_id === anchor.entity_id;
+        const otherId = isHead ? edge.tail_entity_id : edge.head_entity_id;
+        const other = this.entityById.get(otherId);
+        if (!other) continue;
+
+        if (intent.candidate_type) {
+          if (other.type.toLowerCase() !== intent.candidate_type.toLowerCase()) continue;
+        }
+
+        const score = other.mention_count + (other.distinct_session_count * 2);
+
+        candidates.push({
+          value: other.label,
+          score,
+          evidence: edge.evidence.slice(0, 200),
+          supporting_event_ids: edge.supporting_event_ids,
+          entity_id: other.entity_id,
+          scope: `via_${anchor.label}`,
+          support_count: other.mention_count,
+          distinct_session_count: other.distinct_session_count,
+          observed_path: [{
+            from_entity_id: anchor.entity_id,
+            from_label: anchor.label,
+            relation: edge.relation,
+            direction: isHead ? "forward" : "inverse",
+            to_entity_id: other.entity_id,
+            to_label: other.label,
+            supporting_event_ids: edge.supporting_event_ids,
+          }],
+          path_collision_count: 0,
+        });
+
+        groups.push({
+          value: other.label,
+          score,
+          evidence: edge.evidence.slice(0, 200),
+          support_count: other.mention_count,
+          supporting_event_ids: edge.supporting_event_ids,
+          entity_ids: [other.entity_id],
+          scopes: [`via_${anchor.label}`],
+          via_relations: [edge.relation],
+          via_anchor_entity_ids: [anchor.entity_id],
+          observed_path: [{
+            from_entity_id: anchor.entity_id,
+            from_label: anchor.label,
+            relation: edge.relation,
+            direction: isHead ? "forward" : "inverse",
+            to_entity_id: other.entity_id,
+            to_label: other.label,
+            supporting_event_ids: edge.supporting_event_ids,
+          }],
+          path_collision_count: 0,
+        });
+      }
+    }
+
+    candidates.sort((a, b) => b.score - a.score);
+    groups.sort((a, b) => b.score - a.score);
+
+    return {
+      env: this.makeEnvelope(intent, candidates.slice(0, limit), groups.slice(0, limit)),
+      errorClass: "ok",
+    };
+  }
+
+  private makeEnvelope(
+    intent: QueryIntent,
+    candidates: QueryCandidate[],
+    groups: MemoryCandidateGroup[],
+    noDataReason?: string,
+  ): ResponseEnvelope {
+    const manifestPath = path.join(this.bundleRoot, "current", "manifest.json");
+    let bundleVersion: string | undefined;
+    try {
+      const m = JSON.parse(fs.readFileSync(manifestPath, "utf8")) as { bundle_version?: string };
+      bundleVersion = m.bundle_version;
+    } catch { /* ok */ }
+
+    const memoryBlock: MemoryBlock = {
+      groups,
+      notes: [],
+      ...(noDataReason ? { no_data_reason: noDataReason } : {}),
+    };
+
+    return {
+      protocol_version: 1,
+      bundle_version: bundleVersion,
+      request_id: `local-${Date.now()}`,
+      candidates,
+      memory_block: memoryBlock,
+      warnings: [],
+      reason: candidates.length > 0 ? "ok" : "no_data",
+      latency_ms: 0,
+    };
+  }
+}

package/src/paths.ts

@@ -24,5 +24,5 @@ export function defaultSocketPath(): string {
 }
 
 export function defaultSessionsDir(): string {
-  return path.join(defaultPiHome(), "sessions");
+  return path.join(defaultPiHome(), "agent", "sessions");
 }