@yandy0725/pi-memory 0.3.1 → 1.0.1

package/src/agent-types.ts

@@ -0,0 +1,44 @@
+/**
+ * agent-types.ts — Register a single minimal agent type for pi-memory subagents.
+ *
+ * Writes `memory-agent.md` to ~/.pi/agent/agents/ so pi-subagents
+ * picks it up as a custom agent type with restricted tools and replace-mode prompt.
+ * Written during extension factory (before pi-subagents initializes its registry).
+ *
+ * One type serves three tasks:
+ *   - side-query:    thinking=off,  maxTurns=1
+ *   - extractMemories: thinking=high, maxTurns=5
+ *   - dream:         thinking=high  (unlimited turns)
+ *
+ * On first install (before pi restart), pi-subagents auto-falls-back to
+ * general-purpose. No manual action needed.
+ */
+
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
+
+const AGENTS_DIR = join(homedir(), CONFIG_DIR_NAME, "agent", "agents");
+
+const DEFINITION = `---
+description: Memory maintenance agent — file read/write only (no bash/websearch)
+tools: read, write, edit, ls
+prompt_mode: replace
+---
+`;
+
+export function ensureAgentTypes(): void {
+	try {
+		mkdirSync(AGENTS_DIR, { recursive: true });
+	} catch {
+		return;
+	}
+
+	const path = join(AGENTS_DIR, "memory-agent.md");
+	if (!existsSync(path)) {
+		try {
+			writeFileSync(path, DEFINITION, "utf8");
+		} catch {}
+	}
+}

package/src/config.ts

@@ -1,8 +1,22 @@
 import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
 import { homedir } from "node:os";
+import { join } from "node:path";
 import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
 
+export interface AutoSurfacingConfig {
+	enabled: boolean;
+	model: string;
+	maxFiles: number;
+	maxTopicBytes: number;
+	maxInjectionBytes: number;
+}
+
+export interface ExtractMemoriesConfig {
+	enabled: boolean;
+	model: string;
+	maxContextTokens: number;
+}
+
 export interface MemoryConfig {
 	enabled: boolean;
 	memoryDir: string;
@@ -10,6 +24,8 @@ export interface MemoryConfig {
 	memIndexMaxBytes: number;
 	dream: { nudgeAfterSessions: number; nudgeAfterHours: number; model: string };
 	sessionSearch: { maxSessions: number; maxMatches: number };
+	autoSurfacing: AutoSurfacingConfig;
+	extractMemories: ExtractMemoriesConfig;
 }
 
 export const DEFAULT_CONFIG: MemoryConfig = {
@@ -19,6 +35,18 @@ export const DEFAULT_CONFIG: MemoryConfig = {
 	memIndexMaxBytes: 25600,
 	dream: { nudgeAfterSessions: 5, nudgeAfterHours: 24, model: "auto" },
 	sessionSearch: { maxSessions: 10, maxMatches: 5 },
+	autoSurfacing: {
+		enabled: true,
+		model: "auto",
+		maxFiles: 5,
+		maxTopicBytes: 4096,
+		maxInjectionBytes: 20480,
+	},
+	extractMemories: {
+		enabled: true,
+		model: "auto",
+		maxContextTokens: 2000,
+	},
 };
 
 function expandTilde(p: string): string {
@@ -28,12 +56,17 @@ function expandTilde(p: string): string {
 }
 
 function deepMerge<T>(base: T, over: Partial<T>): T {
+	// biome-ignore lint/suspicious/noExplicitAny: generic deep merge
 	const out: any = { ...base };
 	for (const k of Object.keys(over) as (keyof T)[]) {
+		// biome-ignore lint/suspicious/noExplicitAny: generic deep merge
 		const ov = over[k] as any;
+		// biome-ignore lint/suspicious/noExplicitAny: generic deep merge
 		if (ov && typeof ov === "object" && !Array.isArray(ov) && typeof (out as any)[k] === "object") {
+			// biome-ignore lint/suspicious/noExplicitAny: generic deep merge
 			(out as any)[k] = deepMerge((out as any)[k], ov);
 		} else if (ov !== undefined) {
+			// biome-ignore lint/suspicious/noExplicitAny: generic deep merge
 			(out as any)[k] = ov;
 		}
 	}
@@ -61,11 +94,11 @@ export async function loadConfig(ctx: LoadConfigContext): Promise<MemoryConfig>
 	const configDirName = ctx._configDirName ?? CONFIG_DIR_NAME;
 	let cfg: MemoryConfig = { ...DEFAULT_CONFIG };
 
-	const globalFile = join(agentDir, "pi-memory.json");
+	const globalFile = join(agentDir, "memory.json");
 	cfg = deepMerge(cfg, readJsonSafe(globalFile));
 
 	if (ctx.isProjectTrusted()) {
-		const projectFile = join(ctx.cwd, configDirName, "pi-memory.json");
+		const projectFile = join(ctx.cwd, configDirName, "memory.json");
 		cfg = deepMerge(cfg, readJsonSafe(projectFile));
 	}
 

package/src/dream.ts

@@ -1,115 +1,130 @@
-import {
-	createAgentSession,
-	SessionManager,
-	DefaultResourceLoader,
-	SettingsManager,
-	AuthStorage,
-	ModelRegistry,
-} from "@earendil-works/pi-coding-agent";
-import { join } from "node:path";
-import { mkdtemp } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import type { MemoryConfig } from "./config";
-
-export const DREAM_SYSTEM_PROMPT = `You are a memory consolidation agent. Your job: read all memory files in the given directory, consolidate entries within each topic (merge duplicates, resolve contradictions, update outdated info), and rebuild the MEMORY.md index to be concise and accurate.
-Rules:
-- Each topic file contains entries as \`## Entry Title\` blocks.
-- Only modify files under the given directory. Never touch anything else.
-- Deduplicate entries: if two entries in the same topic contain the same info, merge them.
-- If entries across different topics overlap, move the content to the more appropriate topic.
-- Rebuild MEMORY.md index: list entries you deem valuable (not necessarily every entry). Each line: - [Entry Title](topic.md). Accuracy matters more than completeness.
-- CRITICAL for entry titles: Only the MEMORY.md index is injected into future coding sessions (topic file content is NOT seen). Every entry title must be self-descriptive and convey enough context to be useful at a glance. Prefer specific, actionable titles like "use uv instead of pip for Python package management" over vague ones like "python tools" or "workflow rules". If an existing title is too vague, rewrite it — keep the original ## heading in the topic file for full context.
-- When done, output a concise summary of changes (merged N, removed N, moved N, updated N).`;
+import { access } from "node:fs/promises";
+import { getSubagentsService, type SubagentsService, type WorkspaceProvider } from "@yandy0725/pi-subagents";
 
+/** Build dream consolidation task.
+ *  Session context strategy: cwd = memoryDir (via WorkspaceProvider).
+ *  Dream agent sees only the memory files, no parent conversation history.
+ *  Tool scope: full file read/write/edit (needed for consolidation). */
 export function buildDreamTask(memoryDir: string, maxLines: number): string {
-  return `Consolidate the memory files under ${memoryDir}. Read every .md file (including MEMORY.md), then:
-1. Deduplicate entries within each topic that say the same thing.
-2. Merge contradictory or overlapping entries into one accurate entry.
-3. Update outdated information.
-4. Move entries to more appropriate topic files when needed.
-5. Rebuild MEMORY.md (max ${maxLines} lines): - [Entry Title](topic.md) per entry you deem valuable (not necessarily every entry). Entries use ## Entry Title format.
-  IMPORTANT: Only MEMORY.md index lines are injected into future coding sessions (topic file content is NOT seen by the coding agent). Rewrite every entry title to be self-contained and descriptive — like "always use uv instead of pip for Python" instead of just "python tools". The title alone must tell the model what the entry is about.
-Only edit files under ${memoryDir}. When finished, print a one-line summary of changes.`;
-}
+	return `You are a memory consolidation agent. Your job is to read all memory files
+and consolidate them into a clean, deduplicated memory store.
 
-export function resolveDreamModel(config: MemoryConfig, ctx: { model: any; modelRegistry: any }): any | null {
-	if (config.dream.model === "auto") return ctx.model;
-	const slash = config.dream.model.indexOf("/");
-	if (slash === -1) return null;
-	const provider = config.dream.model.slice(0, slash);
-	const id = config.dream.model.slice(slash + 1);
-	return ctx.modelRegistry?.find(provider, id) ?? null;
-}
+Phase 1 — Orient:
+- List all files in ${memoryDir}
+- Read MEMORY.md to understand current index
+- Skim each topic file to understand its contents
+
+Phase 2 — Gather Signal:
+- Find duplicate entries within and across topic files
+- Identify contradictory information
+- Spot outdated or obsolete entries
+- Note temporal references that should be absolute dates
+
+Phase 3 — Consolidate:
+- Merge duplicates into single entries
+- Resolve contradictions — pick the most accurate version
+- Convert relative dates (today, last week) to absolute dates
+- Update outdated information
+- Move entries to more appropriate topic files when needed
+- Delete entries that are no longer relevant
 
-export function extractSummary(messages: any[]): string {
-	for (let i = messages.length - 1; i >= 0; i--) {
-		const m = messages[i];
-		if (m.role === "assistant") {
-			if (typeof m.content === "string") return m.content;
-			const t = (m.content || []).find((b: any) => b.type === "text");
-			if (t) return t.text;
-		}
-	}
-	return "Dream completed.";
+Phase 4 — Prune & Index:
+- For each topic file, update frontmatter:
+  name: meaningful name for the topic
+  description: specific summary that helps LLM match queries (be specific!)
+  type: one of user, feedback, project, reference
+  updated: today's date
+- Generate a compact hook (~150 chars) for each topic summarizing its entries
+- Rebuild MEMORY.md with one line per topic file (max ${maxLines} lines):
+  - [Name](file.md) — hook
+- Remove topic files that have no remaining entries
+
+CRITICAL for hooks and descriptions:
+- Only the MEMORY.md index is injected into future coding sessions.
+  Topic file content is NOT seen by the coding agent unless explicitly
+  read or auto-surfaced. The hook and description must be specific
+  enough that the LLM can correctly decide relevance.
+- Bad: "Debugging tips"
+- Good: "SSH port 2222 on staging; MySQL 30s timeout; Redis auth fix"
+- Each topic file's \`## Entry Title\` blocks contain the actual memory entries.
+  The MEMORY.md line is just a pointer — only ONE line per topic file.
+- When done, output a concise summary of changes (merged N, removed N, moved N, updated N).`;
 }
 
-interface RunDreamOpts {
-	model: any;
+export interface RunDreamOpts {
+	model: string;
 	memoryDir: string;
-	cwd: string;
 	signal?: AbortSignal;
-	createSession?: typeof createAgentSession;
+	// biome-ignore lint/suspicious/noExplicitAny: pi events API handler
+	events?: { on(channel: string, handler: (data: any) => void): () => void };
+	service?: SubagentsService;
 }
 
 export async function runDream(opts: RunDreamOpts): Promise<string> {
-	const createSession = opts.createSession ?? createAgentSession;
-	// DI: when opts.createSession is provided (test path), skip real loader/auth construction.
-	// When not provided (production), build the real isolated DefaultResourceLoader + AuthStorage.
-	const useReal = !opts.createSession;
-	const loader = useReal
-		? await (async () => {
-				const isolatedAgentDir = await mkdtemp(join(tmpdir(), "pi-dream-"));
-				const l = new DefaultResourceLoader({
-					cwd: opts.memoryDir,
-					agentDir: isolatedAgentDir,
-					settingsManager: SettingsManager.inMemory({}),
-					systemPromptOverride: () => DREAM_SYSTEM_PROMPT,
-				});
-				await l.reload();
-				return l;
-			})()
-		: undefined;
-	const authStorage = useReal ? AuthStorage.create() : undefined;
-
-	const { session } = await createSession({
-		model: opts.model,
-		...(authStorage ? { authStorage } : {}),
-		...(useReal ? { modelRegistry: ModelRegistry.create(authStorage!) } : {}),
-		tools: ["read", "edit", "write"],
-		cwd: opts.memoryDir,
-		sessionManager: useReal ? SessionManager.inMemory(opts.memoryDir) : undefined,
-		...(loader ? { resourceLoader: loader } : {}),
-	});
+	const service = opts.service ?? getSubagentsService();
+	if (!service) throw new Error("pi-subagents not available — install @yandy0725/pi-subagents");
 
-	let summary = "Dream completed.";
-	const unsub = session.subscribe((e: any) => {
-		if (e.type === "agent_end") {
-			summary = extractSummary(session.messages);
-		}
-	});
+	const events = opts.events;
+	if (!events) throw new Error("events required for dream — pass pi.events");
+
+	const model = opts.model === "auto" ? undefined : opts.model;
+	const task = buildDreamTask(opts.memoryDir, 200);
 
-	const onAbort = () => session.abort?.();
-	opts.signal?.addEventListener("abort", onAbort);
-	try {
-		await session.prompt(buildDreamTask(opts.memoryDir, 200));
-		// Extract from messages as fallback when agent_end didn't fire (test path / edge case).
-		if (summary === "Dream completed." && session.messages?.length) {
-			summary = extractSummary(session.messages);
-		}
-		return summary;
-	} finally {
-		opts.signal?.removeEventListener("abort", onAbort);
-		unsub();
-		session.dispose();
-	}
+	// Register workspace provider so the subagent runs in memoryDir
+	const provider: WorkspaceProvider = {
+		async prepare(_ctx) {
+			await access(opts.memoryDir).catch(() => {
+				throw new Error(`Memory directory not found: ${opts.memoryDir}`);
+			});
+			return {
+				cwd: opts.memoryDir,
+				dispose: () => undefined,
+			};
+		},
+	};
+	const unregister = service.registerWorkspaceProvider(provider);
+
+	// Spawn the dream subagent
+	const agentId = service.spawn(
+		"memory-agent",
+		task,
+		model ? { model, thinkingLevel: "high" } : { thinkingLevel: "high" },
+	);
+
+	// Wait for completion/failure via pi-subagents events (abort-while-queued
+	// is handled: pi-subagents guarantees events fire for all terminal states).
+	return await new Promise<string>((resolve, reject) => {
+		let settled = false;
+
+		const cleanup = () => {
+			if (settled) return;
+			settled = true;
+			unsubCompleted();
+			unsubFailed();
+			unregister();
+			opts.signal?.removeEventListener("abort", onAbort);
+		};
+
+		const onCompleted = (data: { id: string }) => {
+			if (data.id !== agentId) return;
+			cleanup();
+			const record = service.getRecord(agentId);
+			resolve(record?.result ?? "Dream completed.");
+		};
+
+		const onFailed = (data: { id: string; error?: string }) => {
+			if (data.id !== agentId) return;
+			cleanup();
+			reject(new Error(data.error ?? "Dream agent failed"));
+		};
+
+		const onAbort = () => {
+			service.abort(agentId);
+		};
+
+		const unsubCompleted = events.on("subagents:completed", onCompleted);
+		const unsubFailed = events.on("subagents:failed", onFailed);
+
+		opts.signal?.addEventListener("abort", onAbort, { once: true });
+	});
 }

package/src/extract.ts

@@ -0,0 +1,110 @@
+import { access } from "node:fs/promises";
+import { getSubagentsService, type SubagentsService, type WorkspaceProvider } from "@yandy0725/pi-subagents";
+
+export interface RunExtractOpts {
+	model: string;
+	memoryDir: string;
+	messages: Array<{ role: string; content: string }>;
+	maxContextTokens: number;
+	service?: SubagentsService;
+}
+
+/** Build extraction task prompt.
+ *  Session context strategy: only current turn (user + assistant messages).
+ *  No conversation history — extraction is turn-scoped.
+ *  Tool scope: file read/write only (cwd = memoryDir). */
+export function buildExtractTask(
+	memoryDir: string,
+	messages: Array<{ role: string; content: string }>,
+	maxTokens: number,
+): string {
+	// Find user and assistant messages for context
+	const fromUser = messages.find((m) => m.role === "user");
+	const fromAssistant = messages.findLast((m) => m.role === "assistant");
+	const userText = fromUser?.content ?? "";
+	const assistantText = fromAssistant?.content ?? "";
+
+	// Truncate by maxTokens (rough estimate: ~4 chars/token)
+	const maxChars = maxTokens * 4;
+	const truncatedUser = userText.slice(0, maxChars / 2);
+	const truncatedAssistant = assistantText.slice(0, maxChars / 2);
+
+	return [
+		`You are a memory extraction agent. Your cwd is the memory directory at ${memoryDir}.`,
+		"",
+		"Analyze the conversation snippet below. If you find valuable learnings, write them to topic files in this directory using ONLY file read/write/edit tools. Do NOT use bash, web search, or any other tools.",
+		"The memory directory contains topic files with this frontmatter format:",
+		"",
+		"```yaml",
+		"---",
+		"name: Topic Name",
+		"description: Brief summary for relevance matching",
+		"type: feedback  # one of: user, feedback, project, reference",
+		"updated: 2026-07-13",
+		"---",
+		"",
+		"## Entry Title",
+		"Entry content here.",
+		"```",
+		"",
+		"And MEMORY.md index:",
+		"- [Name](file.md) — one-line hook summary",
+		"",
+		"Worth remembering:",
+		"- User preferences, coding style choices, tooling preferences",
+		"- Project conventions, architecture decisions, naming patterns",
+		"- Debugging insights, workarounds, gotchas discovered",
+		'- "Always do X" / "Never do Y" rules',
+		"- References to external systems or documentation",
+		"",
+		"NOT worth remembering:",
+		"- One-time task instructions or ephemeral details",
+		"- Code snippets or file paths derivable from the project",
+		"- Information already captured in CLAUDE.md or AGENTS.md",
+		"- Git history or recent changes",
+		"",
+		"When writing memories:",
+		"- Use descriptive, self-contained entry titles (only index lines are injected into future sessions)",
+		"- Choose the appropriate type: user, feedback, project, reference",
+		'- Default type is "feedback"',
+		"- Be concise but complete",
+		"- If unsure, do NOT write anything",
+		"- Use the write/edit tools to directly modify topic files and MEMORY.md",
+		"",
+		"=== Conversation ===",
+		`User: ${truncatedUser}`,
+		`Assistant: ${truncatedAssistant}`,
+	].join("\n");
+}
+
+export async function runExtract(opts: RunExtractOpts): Promise<void> {
+	if (opts.messages.length === 0) return;
+
+	const service = opts.service ?? getSubagentsService();
+	if (!service) return; // silently skip if no subagent service
+
+	const model = opts.model === "auto" ? undefined : opts.model;
+	const task = buildExtractTask(opts.memoryDir, opts.messages, opts.maxContextTokens);
+
+	const provider: WorkspaceProvider = {
+		async prepare(_ctx) {
+			await access(opts.memoryDir).catch(() => {
+				throw new Error(`Memory directory not found: ${opts.memoryDir}`);
+			});
+			return {
+				cwd: opts.memoryDir,
+				dispose: () => undefined,
+			};
+		},
+	};
+	service.registerWorkspaceProvider(provider);
+
+	// Fire-and-forget spawn
+	service.spawn(
+		"memory-agent",
+		task,
+		model
+			? { model, inheritContext: false, maxTurns: 5, thinkingLevel: "high" }
+			: { inheritContext: false, maxTurns: 5, thinkingLevel: "high" },
+	);
+}

package/src/index-file.ts

@@ -1,82 +1,91 @@
 export interface IndexEntry {
-  title: string;
-  topic: string;
-  raw: string;
+	name: string; // 原名 title，取自 frontmatter name
+	topic: string; // 文件名
+	hook: string; // 一行描述
+	raw: string; // 原始行文本
 }
+
 export interface IndexFile {
-  entries: IndexEntry[];
-  raw: string;
+	entries: IndexEntry[];
+	raw: string;
 }
 
-// Matches: - [Title](topic.md)
-const LINE_RE = /^-\s+\[([^\]]+)\]\(([^)]+)\)\s*$/;
+// Matches: - [Name](topic.md) — hook
+const LINE_RE = /^-\s+\[([^\]]+)\]\(([^)]+)\)\s*—\s*(.*)$/;
 
 export function parseIndex(content: string): IndexFile {
-  const entries: IndexEntry[] = [];
-  for (const line of content.split("\n")) {
-    const m = line.match(LINE_RE);
-    if (m) entries.push({ title: m[1].trim(), topic: m[2].trim(), raw: line });
-  }
-  return { entries, raw: content };
+	const entries: IndexEntry[] = [];
+	for (const line of content.split("\n")) {
+		const m = line.match(LINE_RE);
+		if (m) {
+			entries.push({
+				name: m[1].trim(),
+				topic: m[2].trim(),
+				hook: m[3].trim(),
+				raw: line,
+			});
+		}
+	}
+	return { entries, raw: content };
 }
 
 export function serializeIndex(entries: IndexEntry[]): string {
-  return entries.map((e) => `- [${e.title}](${e.topic})`).join("\n");
+	return entries.map((e) => `- [${e.name}](${e.topic}) — ${e.hook}`).join("\n");
 }
 
-export function addEntry(entries: IndexEntry[], entry: IndexEntry): IndexEntry[] {
-  return [...entries, entry];
+export function upsertEntryByTopic(entries: IndexEntry[], entry: IndexEntry): IndexEntry[] {
+	const idx = entries.findIndex((e) => e.topic === entry.topic);
+	if (idx === -1) return [...entries, entry];
+	const next = [...entries];
+	next[idx] = entry;
+	return next;
 }
 
-export function removeEntryByTitle(entries: IndexEntry[], title: string): IndexEntry[] {
-  const idx = entries.findIndex((e) => e.title === title);
-  if (idx === -1) throw new Error(`Entry "${title}" not found in index`);
-  const next = [...entries];
-  next.splice(idx, 1);
-  return next;
+export function removeEntryByTopic(entries: IndexEntry[], topic: string): IndexEntry[] {
+	const idx = entries.findIndex((e) => e.topic === topic);
+	if (idx === -1) throw new Error(`Topic "${topic}" not found in index`);
+	const next = [...entries];
+	next.splice(idx, 1);
+	return next;
 }
 
-export interface MatchResult {
-  entry: IndexEntry | null;
-  unique: boolean;
+export function findEntryByTopic(entries: IndexEntry[], topic: string): IndexEntry | null {
+	return entries.find((e) => e.topic === topic) ?? null;
 }
 
-export function matchEntryByTitle(entries: IndexEntry[], title: string): MatchResult {
-  const matches = entries.filter((e) => e.title === title);
-  if (matches.length === 0) return { entry: null, unique: false };
-  if (matches.length === 1) return { entry: matches[0], unique: true };
-  return { entry: matches[0], unique: false };
+export function updateHook(entries: IndexEntry[], topic: string, hook: string): IndexEntry[] {
+	const idx = entries.findIndex((e) => e.topic === topic);
+	if (idx === -1) throw new Error(`Topic "${topic}" not found in index`);
+	const next = [...entries];
+	next[idx] = { ...next[idx], hook, raw: "" };
+	return next;
 }
 
 export function truncateForInjection(
-  content: string,
-  maxLines: number,
-  maxBytes: number,
+	content: string,
+	maxLines: number,
+	maxBytes: number,
 ): { ok: boolean; content: string; truncated: boolean } {
-  const lines = content.split("\n");
-  let out = content;
-  let truncated = false;
-  if (lines.length > maxLines) {
-    out = lines.slice(0, maxLines).join("\n");
-    truncated = true;
-  }
-  if (Buffer.byteLength(out, "utf8") > maxBytes) {
-    let cut = out;
-    while (Buffer.byteLength(cut, "utf8") > maxBytes && cut.length > 0) cut = cut.slice(0, -1);
-    out = cut;
-    truncated = true;
-  }
-  if (truncated) out += `\n[truncated: memory index exceeds injection limit]`;
-  return { ok: !truncated, content: out, truncated };
+	const lines = content.split("\n");
+	let out = content;
+	let truncated = false;
+	if (lines.length > maxLines) {
+		out = lines.slice(0, maxLines).join("\n");
+		truncated = true;
+	}
+	if (Buffer.byteLength(out, "utf8") > maxBytes) {
+		let cut = out;
+		while (Buffer.byteLength(cut, "utf8") > maxBytes && cut.length > 0) cut = cut.slice(0, -1);
+		out = cut;
+		truncated = true;
+	}
+	if (truncated) out += `\n[truncated: memory index exceeds injection limit]`;
+	return { ok: !truncated, content: out, truncated };
 }
 
-export function checkCapacity(
-  entries: IndexEntry[],
-  maxLines: number,
-  maxBytes: number,
-): boolean {
-  const serialized = serializeIndex(entries);
-  if (entries.length > maxLines) return false;
-  if (Buffer.byteLength(serialized, "utf8") > maxBytes) return false;
-  return true;
+export function checkCapacity(entries: IndexEntry[], maxLines: number, maxBytes: number): boolean {
+	const serialized = serializeIndex(entries);
+	if (entries.length > maxLines) return false;
+	if (Buffer.byteLength(serialized, "utf8") > maxBytes) return false;
+	return true;
 }