@askjo/pi-mem 1.0.0

package/lib.ts

@@ -0,0 +1,304 @@
+/**
+ * Pure logic extracted from the memory extension for testability.
+ * No pi API dependencies — just file I/O and string manipulation.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
+
+// --- Config ---
+
+export interface MemoryConfig {
+	memoryDir: string;
+	memoryFile: string;
+	scratchpadFile: string;
+	dailyDir: string;
+	notesDir: string;
+	contextFiles: string[];
+	autocommit: boolean;
+}
+
+export function buildConfig(env: Record<string, string | undefined> = process.env): MemoryConfig {
+	const memoryDir = env.PI_MEMORY_DIR ?? path.join(env.HOME ?? "~", ".pi", "agent", "memory");
+	const dailyDir = env.PI_DAILY_DIR ?? path.join(memoryDir, "daily");
+	const contextFiles = (env.PI_CONTEXT_FILES ?? "")
+		.split(",")
+		.map(f => f.trim())
+		.filter(Boolean);
+	const autocommit = env.PI_AUTOCOMMIT === "1" || env.PI_AUTOCOMMIT === "true";
+
+	return {
+		memoryDir,
+		memoryFile: path.join(memoryDir, "MEMORY.md"),
+		scratchpadFile: path.join(memoryDir, "SCRATCHPAD.md"),
+		dailyDir,
+		notesDir: path.join(memoryDir, "notes"),
+		contextFiles,
+		autocommit,
+	};
+}
+
+// --- Date/time helpers ---
+
+export function todayStr(): string {
+	return new Date().toISOString().slice(0, 10);
+}
+
+export function yesterdayStr(): string {
+	const d = new Date();
+	d.setDate(d.getDate() - 1);
+	return d.toISOString().slice(0, 10);
+}
+
+export function nowTimestamp(): string {
+	return new Date().toISOString().replace("T", " ").replace(/\.\d+Z$/, "");
+}
+
+export function shortSessionId(sessionId: string): string {
+	return sessionId.slice(0, 8);
+}
+
+// --- File helpers ---
+
+export function readFileSafe(filePath: string): string | null {
+	try {
+		return fs.readFileSync(filePath, "utf-8");
+	} catch {
+		return null;
+	}
+}
+
+export function dailyPath(dailyDir: string, date: string): string {
+	return path.join(dailyDir, `${date}.md`);
+}
+
+export function ensureDirs(config: MemoryConfig): void {
+	fs.mkdirSync(config.memoryDir, { recursive: true });
+	fs.mkdirSync(config.dailyDir, { recursive: true });
+	fs.mkdirSync(config.notesDir, { recursive: true });
+}
+
+// --- Scratchpad ---
+
+export interface ScratchpadItem {
+	done: boolean;
+	text: string;
+	meta: string;
+}
+
+export function parseScratchpad(content: string): ScratchpadItem[] {
+	const items: ScratchpadItem[] = [];
+	const lines = content.split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const match = line.match(/^- \[([ xX])\] (.+)$/);
+		if (match) {
+			let meta = "";
+			if (i > 0 && lines[i - 1].match(/^<!--.*-->$/)) {
+				meta = lines[i - 1];
+			}
+			items.push({
+				done: match[1].toLowerCase() === "x",
+				text: match[2],
+				meta,
+			});
+		}
+	}
+	return items;
+}
+
+export function serializeScratchpad(items: ScratchpadItem[]): string {
+	const lines: string[] = ["# Scratchpad", ""];
+	for (const item of items) {
+		if (item.meta) {
+			lines.push(item.meta);
+		}
+		const checkbox = item.done ? "[x]" : "[ ]";
+		lines.push(`- ${checkbox} ${item.text}`);
+	}
+	return lines.join("\n") + "\n";
+}
+
+// --- Memory context builder ---
+
+export function buildMemoryContext(config: MemoryConfig): string {
+	ensureDirs(config);
+	const sections: string[] = [];
+
+	for (const fileName of config.contextFiles) {
+		const filePath = path.join(config.memoryDir, fileName);
+		const content = readFileSafe(filePath);
+		if (content?.trim()) {
+			sections.push(`## ${fileName}\n\n${content.trim()}`);
+		}
+	}
+
+	const longTerm = readFileSafe(config.memoryFile);
+	if (longTerm?.trim()) {
+		sections.push(`## MEMORY.md (long-term)\n\n${longTerm.trim()}`);
+	}
+
+	const scratchpad = readFileSafe(config.scratchpadFile);
+	if (scratchpad?.trim()) {
+		const openItems = parseScratchpad(scratchpad).filter((i) => !i.done);
+		if (openItems.length > 0) {
+			sections.push(`## SCRATCHPAD.md (working context)\n\n${serializeScratchpad(openItems)}`);
+		}
+	}
+
+	const today = todayStr();
+	const yesterday = yesterdayStr();
+
+	const todayContent = readFileSafe(dailyPath(config.dailyDir, today));
+	if (todayContent?.trim()) {
+		sections.push(`## Daily log: ${today} (today)\n\n${todayContent.trim()}`);
+	}
+
+	const yesterdayContent = readFileSafe(dailyPath(config.dailyDir, yesterday));
+	if (yesterdayContent?.trim()) {
+		sections.push(`## Daily log: ${yesterday} (yesterday)\n\n${yesterdayContent.trim()}`);
+	}
+
+	if (sections.length === 0) {
+		return "";
+	}
+
+	return `# Memory\n\n${sections.join("\n\n---\n\n")}`;
+}
+
+// --- Session scanner ---
+
+const LOOKBACK_MS = 24 * 60 * 60 * 1000;
+
+export interface SessionInfo {
+	file: string;
+	timestamp: string;
+	title: string;
+	isChild: boolean;
+	parentSession?: string;
+	cwd: string;
+	cost: number;
+}
+
+export async function scanSession(filePath: string): Promise<SessionInfo | null> {
+	try {
+		const cutoffTime = Date.now() - LOOKBACK_MS;
+		const rl = createInterface({ input: createReadStream(filePath), crlfDelay: Infinity });
+		let lineNum = 0;
+		let header: any = null;
+		let title = "";
+		let totalCost = 0;
+
+		for await (const line of rl) {
+			lineNum++;
+			if (lineNum === 1) {
+				try {
+					header = JSON.parse(line);
+				} catch { return null; }
+				if (header.timestamp && new Date(header.timestamp).getTime() < cutoffTime) {
+					rl.close();
+					return null;
+				}
+				continue;
+			}
+			try {
+				const entry = JSON.parse(line);
+				if (entry.type === "session_info" && entry.name) {
+					title = entry.name;
+				}
+				if (entry.type === "message" && entry.message?.role === "assistant" && entry.message?.usage?.cost?.total) {
+					totalCost += entry.message.usage.cost.total;
+				}
+			} catch { continue; }
+		}
+
+		if (!header?.timestamp) return null;
+
+		if (!title) {
+			const rl2 = createInterface({ input: createReadStream(filePath), crlfDelay: Infinity });
+			for await (const line of rl2) {
+				try {
+					const entry = JSON.parse(line);
+					if (entry.type === "message" && entry.message?.role === "user") {
+						const content = entry.message.content;
+						if (typeof content === "string") {
+							title = content.slice(0, 80);
+						} else if (Array.isArray(content)) {
+							const textPart = content.find((c: any) => c.type === "text");
+							if (textPart) title = textPart.text.slice(0, 80);
+						}
+						break;
+					}
+				} catch { continue; }
+			}
+		}
+
+		return {
+			file: filePath,
+			timestamp: header.timestamp,
+			title: title || "(untitled)",
+			isChild: !!header.parentSession,
+			parentSession: header.parentSession || undefined,
+			cwd: header.cwd || "",
+			cost: totalCost,
+		};
+	} catch { return null; }
+}
+
+export function isHousekeeping(title: string): boolean {
+	const lower = title.toLowerCase();
+	const patterns = [
+		/^(clear|review|read)\s+(done|scratchpad|today|daily)/,
+		/^-\s+(no done|scratchpad|cleared|reviewed|task is)/,
+		/^scratchpad\s+(content|management|maintenance|reviewed|items)/,
+		/^\(untitled\)$/,
+		/^\/\w+$/,
+		/^write daily log/,
+	];
+	return patterns.some(p => p.test(lower));
+}
+
+// --- Search ---
+
+export interface SearchResult {
+	fileMatches: string[];
+	lineResults: { file: string; line: number; text: string }[];
+}
+
+export function searchMemory(config: MemoryConfig, query: string, maxResults: number = 20): SearchResult {
+	const needle = query.toLowerCase();
+	const fileMatches: string[] = [];
+	const lineResults: { file: string; line: number; text: string }[] = [];
+
+	function searchFile(filePath: string, displayName: string) {
+		if (displayName.toLowerCase().includes(needle) && !fileMatches.includes(displayName)) {
+			fileMatches.push(displayName);
+		}
+		const content = readFileSafe(filePath);
+		if (!content) return;
+		const lines = content.split("\n");
+		for (let i = 0; i < lines.length && lineResults.length < maxResults; i++) {
+			if (lines[i].toLowerCase().includes(needle)) {
+				lineResults.push({ file: displayName, line: i + 1, text: lines[i].trimEnd() });
+			}
+		}
+	}
+
+	function searchDir(dir: string, prefix: string) {
+		try {
+			const files = fs.readdirSync(dir).filter(f => f.endsWith(".md")).sort();
+			for (const f of files) {
+				if (lineResults.length >= maxResults) break;
+				searchFile(path.join(dir, f), prefix ? `${prefix}/${f}` : f);
+			}
+		} catch {}
+	}
+
+	searchDir(config.memoryDir, "");
+	searchDir(config.dailyDir, "daily");
+	searchDir(config.notesDir, "notes");
+
+	return { fileMatches, lineResults };
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@askjo/pi-mem",
+  "version": "1.0.0",
+  "description": "Pi coding agent extension for plain-Markdown memory system — long-term memory, daily logs, and scratchpad checklist",
+  "main": "index.ts",
+  "type": "module",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "pi",
+    "pi-coding-agent",
+    "memory",
+    "context",
+    "scratchpad",
+    "daily-log"
+  ],
+  "scripts": {
+    "test": "node --import tsx --test tests/*.test.ts"
+  },
+  "author": "jo-inc",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jo-inc/pi-mem.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jo-inc/pi-mem/issues"
+  },
+  "homepage": "https://github.com/jo-inc/pi-mem#readme",
+  "pi": {
+    "extensions": ["./index.ts"],
+    "image": "https://raw.githubusercontent.com/jo-inc/pi-mem/main/logo.png"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-ai": "*",
+    "@mariozechner/pi-tui": "*",
+    "@sinclair/typebox": "*"
+  },
+  "devDependencies": {
+    "tsx": "^4.19.0",
+    "@types/node": "^22.0.0"
+  }
+}

package/tests/config.test.ts

@@ -0,0 +1,71 @@
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import * as path from "node:path";
+import { buildConfig } from "../lib.ts";
+
+describe("buildConfig", () => {
+	it("uses defaults when no env vars set", () => {
+		const config = buildConfig({ HOME: "/home/testuser" });
+		assert.strictEqual(config.memoryDir, "/home/testuser/.pi/agent/memory");
+		assert.strictEqual(config.memoryFile, "/home/testuser/.pi/agent/memory/MEMORY.md");
+		assert.strictEqual(config.scratchpadFile, "/home/testuser/.pi/agent/memory/SCRATCHPAD.md");
+		assert.strictEqual(config.dailyDir, "/home/testuser/.pi/agent/memory/daily");
+		assert.strictEqual(config.notesDir, "/home/testuser/.pi/agent/memory/notes");
+		assert.deepStrictEqual(config.contextFiles, []);
+		assert.strictEqual(config.autocommit, false);
+	});
+
+	it("respects PI_MEMORY_DIR override", () => {
+		const config = buildConfig({ HOME: "/home/x", PI_MEMORY_DIR: "/custom/mem" });
+		assert.strictEqual(config.memoryDir, "/custom/mem");
+		assert.strictEqual(config.memoryFile, "/custom/mem/MEMORY.md");
+		assert.strictEqual(config.scratchpadFile, "/custom/mem/SCRATCHPAD.md");
+		assert.strictEqual(config.notesDir, "/custom/mem/notes");
+	});
+
+	it("respects PI_DAILY_DIR override independently of memory dir", () => {
+		const config = buildConfig({ HOME: "/home/x", PI_DAILY_DIR: "/other/daily" });
+		assert.strictEqual(config.dailyDir, "/other/daily");
+		assert.strictEqual(config.memoryDir, "/home/x/.pi/agent/memory");
+	});
+
+	it("parses PI_CONTEXT_FILES as comma-separated list", () => {
+		const config = buildConfig({ HOME: "/home/x", PI_CONTEXT_FILES: "SOUL.md, AGENTS.md, HEARTBEAT.md" });
+		assert.deepStrictEqual(config.contextFiles, ["SOUL.md", "AGENTS.md", "HEARTBEAT.md"]);
+	});
+
+	it("handles empty PI_CONTEXT_FILES", () => {
+		const config = buildConfig({ HOME: "/home/x", PI_CONTEXT_FILES: "" });
+		assert.deepStrictEqual(config.contextFiles, []);
+	});
+
+	it("handles PI_CONTEXT_FILES with extra whitespace and trailing comma", () => {
+		const config = buildConfig({ HOME: "/home/x", PI_CONTEXT_FILES: " A.md ,  B.md , " });
+		assert.deepStrictEqual(config.contextFiles, ["A.md", "B.md"]);
+	});
+
+	it("enables autocommit with PI_AUTOCOMMIT=1", () => {
+		const config = buildConfig({ HOME: "/home/x", PI_AUTOCOMMIT: "1" });
+		assert.strictEqual(config.autocommit, true);
+	});
+
+	it("enables autocommit with PI_AUTOCOMMIT=true", () => {
+		const config = buildConfig({ HOME: "/home/x", PI_AUTOCOMMIT: "true" });
+		assert.strictEqual(config.autocommit, true);
+	});
+
+	it("does not enable autocommit with PI_AUTOCOMMIT=0", () => {
+		const config = buildConfig({ HOME: "/home/x", PI_AUTOCOMMIT: "0" });
+		assert.strictEqual(config.autocommit, false);
+	});
+
+	it("does not enable autocommit with PI_AUTOCOMMIT=yes", () => {
+		const config = buildConfig({ HOME: "/home/x", PI_AUTOCOMMIT: "yes" });
+		assert.strictEqual(config.autocommit, false);
+	});
+
+	it("falls back to ~ when HOME is undefined", () => {
+		const config = buildConfig({});
+		assert.strictEqual(config.memoryDir, "~/.pi/agent/memory");
+	});
+});

package/tests/date-helpers.test.ts

@@ -0,0 +1,72 @@
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { todayStr, yesterdayStr, nowTimestamp, shortSessionId, dailyPath } from "../lib.ts";
+
+describe("todayStr", () => {
+	it("returns YYYY-MM-DD format", () => {
+		const result = todayStr();
+		assert.match(result, /^\d{4}-\d{2}-\d{2}$/);
+	});
+
+	it("matches current date", () => {
+		const expected = new Date().toISOString().slice(0, 10);
+		assert.strictEqual(todayStr(), expected);
+	});
+});
+
+describe("yesterdayStr", () => {
+	it("returns YYYY-MM-DD format", () => {
+		const result = yesterdayStr();
+		assert.match(result, /^\d{4}-\d{2}-\d{2}$/);
+	});
+
+	it("is exactly one day before today", () => {
+		const today = new Date(todayStr());
+		const yesterday = new Date(yesterdayStr());
+		const diffMs = today.getTime() - yesterday.getTime();
+		assert.strictEqual(diffMs, 24 * 60 * 60 * 1000);
+	});
+});
+
+describe("nowTimestamp", () => {
+	it("returns space-separated date and time", () => {
+		const ts = nowTimestamp();
+		assert.match(ts, /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);
+	});
+
+	it("does not contain T or Z", () => {
+		const ts = nowTimestamp();
+		assert.ok(!ts.includes("T"));
+		assert.ok(!ts.includes("Z"));
+	});
+});
+
+describe("shortSessionId", () => {
+	it("returns first 8 characters", () => {
+		assert.strictEqual(shortSessionId("abcdefghijklmnop"), "abcdefgh");
+	});
+
+	it("handles UUID-style IDs", () => {
+		assert.strictEqual(shortSessionId("550e8400-e29b-41d4-a716-446655440000"), "550e8400");
+	});
+
+	it("handles short input gracefully", () => {
+		assert.strictEqual(shortSessionId("abc"), "abc");
+	});
+
+	it("returns empty string for empty input", () => {
+		assert.strictEqual(shortSessionId(""), "");
+	});
+});
+
+describe("dailyPath", () => {
+	it("builds correct path for a date", () => {
+		const result = dailyPath("/mem/daily", "2026-02-18");
+		assert.strictEqual(result, "/mem/daily/2026-02-18.md");
+	});
+
+	it("handles trailing slash in dir", () => {
+		const result = dailyPath("/mem/daily/", "2026-01-01");
+		assert.ok(result.endsWith("2026-01-01.md"));
+	});
+});

package/tests/file-helpers.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { readFileSafe, ensureDirs } from "../lib.ts";
+import { makeTempDir, cleanup, makeConfig, writeFile } from "./helpers.ts";
+
+let tmpDir: string;
+
+beforeEach(() => { tmpDir = makeTempDir(); });
+afterEach(() => { cleanup(tmpDir); });
+
+describe("readFileSafe", () => {
+	it("reads an existing file", () => {
+		const filePath = path.join(tmpDir, "test.md");
+		fs.writeFileSync(filePath, "hello world", "utf-8");
+		assert.strictEqual(readFileSafe(filePath), "hello world");
+	});
+
+	it("returns null for non-existent file", () => {
+		assert.strictEqual(readFileSafe(path.join(tmpDir, "nope.md")), null);
+	});
+
+	it("returns null for directory path", () => {
+		assert.strictEqual(readFileSafe(tmpDir), null);
+	});
+
+	it("reads empty file as empty string", () => {
+		const filePath = path.join(tmpDir, "empty.md");
+		fs.writeFileSync(filePath, "", "utf-8");
+		assert.strictEqual(readFileSafe(filePath), "");
+	});
+
+	it("reads file with unicode content", () => {
+		const filePath = path.join(tmpDir, "unicode.md");
+		fs.writeFileSync(filePath, "Hello \u2192 World \ud83d\ude80", "utf-8");
+		assert.strictEqual(readFileSafe(filePath), "Hello \u2192 World \ud83d\ude80");
+	});
+});
+
+describe("ensureDirs", () => {
+	it("creates all directories", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		assert.ok(fs.existsSync(config.memoryDir));
+		assert.ok(fs.existsSync(config.dailyDir));
+		assert.ok(fs.existsSync(config.notesDir));
+	});
+
+	it("is idempotent — calling twice doesn't throw", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		ensureDirs(config);
+		assert.ok(fs.existsSync(config.memoryDir));
+	});
+
+	it("doesn't destroy existing files in directories", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		const testFile = path.join(config.memoryDir, "existing.md");
+		fs.writeFileSync(testFile, "keep me", "utf-8");
+		ensureDirs(config);
+		assert.strictEqual(fs.readFileSync(testFile, "utf-8"), "keep me");
+	});
+});

package/tests/helpers.ts

@@ -0,0 +1,31 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import type { MemoryConfig } from "../lib.ts";
+
+export function makeTempDir(): string {
+	return fs.mkdtempSync(path.join(os.tmpdir(), "pi-mem-test-"));
+}
+
+export function cleanup(dir: string): void {
+	fs.rmSync(dir, { recursive: true, force: true });
+}
+
+export function makeConfig(baseDir: string, overrides: Partial<MemoryConfig> = {}): MemoryConfig {
+	const memoryDir = path.join(baseDir, "memory");
+	return {
+		memoryDir,
+		memoryFile: path.join(memoryDir, "MEMORY.md"),
+		scratchpadFile: path.join(memoryDir, "SCRATCHPAD.md"),
+		dailyDir: path.join(memoryDir, "daily"),
+		notesDir: path.join(memoryDir, "notes"),
+		contextFiles: [],
+		autocommit: false,
+		...overrides,
+	};
+}
+
+export function writeFile(filePath: string, content: string): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, content, "utf-8");
+}