pi-observational-memory 1.0.3 → 2.1.0

package/src/tokens.ts

@@ -1,52 +1,27 @@
 import { estimateTokens as estimateMessageTokens } from "@mariozechner/pi-coding-agent";
 
-export function estimateTokens(text: string): number {
+export function estimateStringTokens(text: string): number {
 	return Math.ceil(text.length / 4);
 }
 
-export function estimateRawTailTokens(
-	entries: Array<{ type: string; message?: unknown; content?: unknown; firstKeptEntryId?: string; id?: string }>,
-): number {
-	let startIndex = 0;
-	for (let i = entries.length - 1; i >= 0; i--) {
-		if (entries[i].type === "compaction") {
-			const keptId = entries[i].firstKeptEntryId;
-			if (keptId) {
-				for (let j = 0; j < entries.length; j++) {
-					if (entries[j].id === keptId) {
-						startIndex = j;
-						break;
-					}
-				}
-			} else {
-				startIndex = i + 1;
-			}
-			break;
-		}
+export function estimateEntryTokens(entry: { type: string; message?: unknown; content?: unknown; summary?: unknown }): number {
+	if (entry.type === "message" && entry.message) {
+		return estimateMessageTokens(entry.message as Parameters<typeof estimateMessageTokens>[0]);
 	}
-
-	let tokens = 0;
-	for (let i = startIndex; i < entries.length; i++) {
-		const entry = entries[i];
-		if (entry.type === "message" && entry.message) {
-			tokens += estimateMessageTokens(entry.message as Parameters<typeof estimateMessageTokens>[0]);
-		} else if (entry.type === "custom_message" && entry.content) {
-			const content = entry.content;
-			if (typeof content === "string") {
-				tokens += Math.ceil(content.length / 4);
-			} else if (Array.isArray(content)) {
-				for (const block of content) {
-					if (block.type === "text" && block.text) tokens += Math.ceil(block.text.length / 4);
-				}
+	if (entry.type === "custom_message" && entry.content) {
+		const content = entry.content;
+		if (typeof content === "string") return estimateStringTokens(content);
+		if (Array.isArray(content)) {
+			let total = 0;
+			for (const block of content) {
+				if (block.type === "text" && block.text) total += estimateStringTokens(block.text);
 			}
+			return total;
 		}
 	}
-	return tokens;
+	if (entry.type === "branch_summary" && typeof entry.summary === "string") {
+		return estimateStringTokens(entry.summary);
+	}
+	return 0;
 }
 
-export function extractText(response: { content: Array<{ type: string; text?: string }> }): string {
-	return response.content
-		.filter((c): c is { type: "text"; text: string } => c.type === "text")
-		.map((c) => c.text)
-		.join("\n");
-}

package/src/types.ts

@@ -1,15 +1,64 @@
-export interface MemoryState {
-	observations: string;
-	reflections: string;
+export const OBSERVATION_CUSTOM_TYPE = "om.observation";
+
+export type Relevance = "low" | "medium" | "high" | "critical";
+
+export const RELEVANCE_VALUES: readonly Relevance[] = ["low", "medium", "high", "critical"] as const;
+
+export interface ObservationRecord {
+	id: string;
+	content: string;
+	timestamp: string;
+	relevance: Relevance;
 }
 
+export type Reflection = string;
+
 export interface MemoryDetails {
 	type: "observational-memory";
-	version: 1;
-	observations: string;
-	reflections: string;
+	version: 3;
+	observations: ObservationRecord[];
+	reflections: Reflection[];
+}
+
+export interface ObservationEntryData {
+	records: ObservationRecord[];
+	coversFromId: string;
+	coversUpToId: string;
+	tokenCount: number;
+}
+
+function isRelevance(v: unknown): v is Relevance {
+	return typeof v === "string" && (RELEVANCE_VALUES as readonly string[]).includes(v);
+}
+
+function isObservationRecord(v: unknown): v is ObservationRecord {
+	if (!v || typeof v !== "object") return false;
+	const o = v as Record<string, unknown>;
+	return (
+		typeof o.id === "string" &&
+		typeof o.content === "string" &&
+		typeof o.timestamp === "string" &&
+		isRelevance(o.relevance)
+	);
 }
 
 export function isMemoryDetails(d: unknown): d is MemoryDetails {
-	return !!d && typeof d === "object" && (d as Record<string, unknown>).type === "observational-memory";
+	if (!d || typeof d !== "object") return false;
+	const o = d as Record<string, unknown>;
+	if (o.type !== "observational-memory" || o.version !== 3) return false;
+	if (!Array.isArray(o.observations) || !Array.isArray(o.reflections)) return false;
+	if (!o.observations.every(isObservationRecord)) return false;
+	return o.reflections.every((r) => typeof r === "string");
+}
+
+export function isObservationEntryData(d: unknown): d is ObservationEntryData {
+	if (!d || typeof d !== "object") return false;
+	const o = d as Record<string, unknown>;
+	return (
+		Array.isArray(o.records) &&
+		o.records.every(isObservationRecord) &&
+		typeof o.coversFromId === "string" &&
+		typeof o.coversUpToId === "string" &&
+		typeof o.tokenCount === "number"
+	);
 }