@henryqw/pi-auto-compact 0.1.2 → 0.2.2

package/README.md

@@ -26,14 +26,26 @@ Remove with:
 pi remove npm:@henryqw/pi-auto-compact
 ```
 
+## Configure
+
+Run `/auto-compact`, then enter threshold percentage. Config lives in `~/.pi/agent/config/pi-auto-compact.json`:
+
+```json
+{
+  "autoCompactThreshold": 50
+}
+```
+
+Threshold must be at least 25% and below 100%; lower values are not meaningful. Missing config defaults to 50%. Restart or `/reload` after manual edits; command changes apply immediately.
+
 ## Behavior
 
 - Refuses activation with an error when Pi's effective `compaction.enabled` setting is not `false`; competing automatic compactors can start duplicate summaries.
-- Checks `turn_start`, tool-call `turn_end`, `context`, and resumed/forked `session_start`.
+- Checks `turn_start`, tool-call `turn_end`, `agent_end`, `context`, and resumed/forked `session_start`.
 - Uses Pi's default `ctx.compact()` summary and session persistence.
 - Keeps newest 15% as temporary emergency context while compaction runs.
-- Sends a follow-up message after compaction so task execution continues.
-- Uses fixed 50% threshold; no extension-specific configuration.
+- Sends a follow-up message after mid-task compaction so task execution continues; final-answer compaction stays idle.
+- Compacts above configured `autoCompactThreshold` percentage (50% by default).
 
 `ctx.compact()` aborts current low-level run. Extension hides that empty internal abort message, then starts new run with current task resume message. Other aborts and provider errors remain visible.
 

package/extensions/auto-compact.ts

@@ -1,3 +1,5 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import {
 	estimateTokens,
 	getAgentDir,
@@ -11,15 +13,48 @@ import type {
 type AgentMessage = Parameters<typeof estimateTokens>[0];
 
 /**
- * Proactive compaction runs at three points:
+ * Proactive compaction runs at four points:
  * - turn_start: catch sessions already over threshold before next request.
  * - turn_end: catch growth caused by tool results before next LLM turn.
+ * - agent_end: catch growth from the final provider turn.
  * - context: last-resort guard with a temporary keep-recent context.
  *
- * Pi's ctx.compact() aborts active low-level run internally. Its completion
- * callback sends follow-up user message, which resumes task after summary.
+ * Pi's ctx.compact() aborts active low-level run internally. Mid-task
+ * compaction sends a follow-up user message to resume work after summary.
  */
-const COMPACT_THRESHOLD_PERCENT = 50;
+const DEFAULT_COMPACT_THRESHOLD_PERCENT = 50;
+const MIN_COMPACT_THRESHOLD_PERCENT = 25;
+const configPath = () => join(getAgentDir(), "config", "pi-auto-compact.json");
+
+function isValidThreshold(value: unknown): value is number {
+	return typeof value === "number" && Number.isFinite(value) && value >= MIN_COMPACT_THRESHOLD_PERCENT && value < 100;
+}
+
+function readConfig(): { autoCompactThreshold: number } {
+	let value: unknown;
+	try {
+		value = JSON.parse(readFileSync(configPath(), "utf8"));
+	} catch (error) {
+		if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+			return { autoCompactThreshold: DEFAULT_COMPACT_THRESHOLD_PERCENT };
+		}
+		throw error;
+	}
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		throw new Error("Config must be an object.");
+	}
+	const threshold = (value as Record<string, unknown>).autoCompactThreshold ?? DEFAULT_COMPACT_THRESHOLD_PERCENT;
+	if (!isValidThreshold(threshold)) {
+		throw new Error(`autoCompactThreshold must be at least ${MIN_COMPACT_THRESHOLD_PERCENT} and below 100.`);
+	}
+	return { autoCompactThreshold: threshold };
+}
+
+function writeConfig(autoCompactThreshold: number): void {
+	const file = configPath();
+	mkdirSync(dirname(file), { recursive: true });
+	writeFileSync(file, `${JSON.stringify({ autoCompactThreshold }, null, 2)}\n`);
+}
 
 // Emergency context guard keeps recent messages while default compaction runs.
 const KEEP_RECENT_PERCENT = 15;
@@ -84,16 +119,18 @@ function hasToolCall(message: AgentMessage): boolean {
 
 export default function (pi: ExtensionAPI) {
 	let active = false;
-	// Prevent turn_start, turn_end, and context from starting duplicate summaries.
+	let autoCompactThreshold = DEFAULT_COMPACT_THRESHOLD_PERCENT;
+	// Prevent lifecycle hooks from starting duplicate summaries.
 	let compactionPending = false;
 	let compactionAbortExpected = false;
 
-	const runCompaction = (ctx: ExtensionContext) => {
+	const runCompaction = (ctx: ExtensionContext, resumeTask = true) => {
 		compactionAbortExpected = Boolean(ctx.signal && !ctx.signal.aborted);
 		ctx.compact({
 			onComplete: () => {
 				compactionPending = false;
 				compactionAbortExpected = false;
+				if (!resumeTask) return;
 				// Pi may flush queued input during compaction_end. Wait one macrotask
 				// before checking idle, otherwise follow-up can race that flush.
 				setImmediate(() => {
@@ -107,14 +144,14 @@ export default function (pi: ExtensionAPI) {
 		});
 	};
 
-	const compactIfNeeded = (ctx: ExtensionContext) => {
+	const compactIfNeeded = (ctx: ExtensionContext, resumeTask = true) => {
 		if (!active || compactionPending) return;
 
 		const usage = ctx.getContextUsage();
-		if (usage?.percent == null || usage.percent <= COMPACT_THRESHOLD_PERCENT) return;
+		if (usage?.percent == null || usage.percent <= autoCompactThreshold) return;
 
 		compactionPending = true;
-		runCompaction(ctx);
+		runCompaction(ctx, resumeTask);
 	};
 
 	// Hide only empty abort produced when ctx.compact() cancels active run.
@@ -141,12 +178,14 @@ export default function (pi: ExtensionAPI) {
 	// Pre-turn catches resumed/queued work before provider request starts.
 	pi.on("turn_start", (_event, ctx) => compactIfNeeded(ctx));
 
-	// Only tool-call turns need mid-run compaction. Final answers should not
-	// receive an unsolicited continuation message.
+	// Only tool-call turns need mid-run compaction.
 	pi.on("turn_end", (event, ctx) => {
 		if (hasToolCall(event.message)) compactIfNeeded(ctx);
 	});
 
+	// Catch threshold crossings caused by the final provider turn.
+	pi.on("agent_end", (_event, ctx) => compactIfNeeded(ctx, false));
+
 	// Runs before every provider request. Temporary truncation protects request
 	// size while asynchronous default compaction summarizes persisted history.
 	pi.on("context", (event, ctx) => {
@@ -154,7 +193,7 @@ export default function (pi: ExtensionAPI) {
 
 		const contextWindow = ctx.getContextUsage()?.contextWindow ?? ctx.model?.contextWindow ?? 0;
 		const estimatedTokens = estimateTotalTokens(event.messages);
-		if (contextWindow <= 0 || estimatedTokens <= contextWindow * COMPACT_THRESHOLD_PERCENT / 100) return;
+		if (contextWindow <= 0 || estimatedTokens <= contextWindow * autoCompactThreshold / 100) return;
 
 		const truncated = keepRecent(
 			event.messages,
@@ -169,9 +208,54 @@ export default function (pi: ExtensionAPI) {
 		return { messages: truncated };
 	});
 
+	pi.registerCommand("auto-compact", {
+		description: "set automatic compaction threshold",
+		handler: async (_args, ctx) => {
+			let current: number;
+			try {
+				current = readConfig().autoCompactThreshold;
+			} catch {
+				ctx.ui.notify("Couldn't read pi-auto-compact config.", "error");
+				return;
+			}
+
+			const input = await ctx.ui.input(
+				`Auto-compact threshold (%) · current: ${current}`,
+				"Enter a number above 0 and below 100",
+			);
+			if (input === undefined) return;
+
+			const threshold = Number(input.trim());
+			if (Number.isFinite(threshold) && threshold < MIN_COMPACT_THRESHOLD_PERCENT) {
+				ctx.ui.notify("Auto-compact threshold below 25% is not meaningful.", "error");
+				return;
+			}
+			if (!isValidThreshold(threshold)) {
+				ctx.ui.notify("Threshold must be at least 25% and below 100%.", "error");
+				return;
+			}
+
+			try {
+				writeConfig(threshold);
+			} catch {
+				ctx.ui.notify("Couldn't save pi-auto-compact config.", "error");
+				return;
+			}
+			autoCompactThreshold = threshold;
+			ctx.ui.notify(`Auto-compact threshold set to ${threshold}%.`, "info");
+		},
+	});
+
 	// Pi's built-in automatic compaction competes with this extension. Refuse
 	// activation unless effective global/project settings disable it.
 	pi.on("session_start", (event, ctx) => {
+		try {
+			autoCompactThreshold = readConfig().autoCompactThreshold;
+		} catch {
+			autoCompactThreshold = DEFAULT_COMPACT_THRESHOLD_PERCENT;
+			ctx.ui.notify("Couldn't read pi-auto-compact config; using 50%.", "error");
+		}
+
 		active = !SettingsManager.create(ctx.cwd, getAgentDir(), {
 			projectTrusted: ctx.isProjectTrusted(),
 		}).getCompactionEnabled();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@henryqw/pi-auto-compact",
-  "version": "0.1.2",
-  "description": "Proactively compact Pi context at 50% and resume the current task.",
+  "version": "0.2.2",
+  "description": "Proactively compact Pi context at a configurable threshold and resume the current task.",
   "keywords": [
     "pi-package",
     "pi",