@henryqw/pi-auto-compact 0.2.2 → 1.0.1

package/README.md

@@ -1,13 +1,16 @@
 # `@henryqw/pi-auto-compact`
 
-Pi extension that compacts context before it reaches 50% of current model context, then resumes current task.
+Compact context before it hits the configured threshold, then resume the current task.
 
 ## Install
 
 ```bash
+pi install npm:@henryqw/pi-task-models
 pi install npm:@henryqw/pi-auto-compact
 ```
 
+`pi-task-models` provides `/task-models` for the shared compaction routes. Requires Pi Coding Agent 0.84.2+.
+
 Disable Pi's built-in auto-compaction in `~/.pi/agent/settings.json`:
 
 ```json
@@ -18,17 +21,20 @@ Disable Pi's built-in auto-compaction in `~/.pi/agent/settings.json`:
 }
 ```
 
-Restart Pi after installation or settings changes. Trusted project settings in `.pi/settings.json` must not override `compaction.enabled` back to `true`. Manual `/compact` remains available.
+Restart Pi after install or settings changes. Trusted project settings in `.pi/settings.json` must not set `compaction.enabled` back to `true`. Manual `/compact` stays available.
 
-Remove with:
+## Use
 
-```bash
-pi remove npm:@henryqw/pi-auto-compact
-```
+| Surface | Purpose |
+| --- | --- |
+| `/auto-compact` | Set the compaction threshold. |
+| `/task-models` | Configure the shared `pi-auto-compact/autoCompact` profile (default `balanced`). |
+
+Refuses to activate unless effective `compaction.enabled` is `false`. Checks `turn_start`, tool-call `turn_end`, `agent_end`, `context`, and resumed or forked `session_start`. Tries the assigned profile primary, then fallback; if neither route works, the current session model still compacts. After mid-task compaction, a follow-up message continues the current task.
 
-## Configure
+## Config
 
-Run `/auto-compact`, then enter threshold percentage. Config lives in `~/.pi/agent/config/pi-auto-compact.json`:
+`~/.pi/agent/config/pi-auto-compact.json`
 
 ```json
 {
@@ -36,25 +42,24 @@ Run `/auto-compact`, then enter threshold percentage. Config lives in `~/.pi/age
 }
 ```
 
-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
+Threshold must be at least 25 and below 100. Missing config defaults to 50. Model routes live in `~/.pi/agent/config/pi-task-models.json`. Malformed shared task-model config is reported and left unchanged.
 
-- 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`, `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 mid-task compaction so task execution continues; final-answer compaction stays idle.
-- Compacts above configured `autoCompactThreshold` percentage (50% by default).
+## Remove
 
-`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.
+```bash
+pi remove npm:@henryqw/pi-auto-compact
+```
 
 ## Development
 
 ```bash
-npm test
-npm run pack:check
-npm run test:live
+npm test --workspace @henryqw/pi-auto-compact
+npm run typecheck --workspace @henryqw/pi-auto-compact
+npm run pack:check --workspace @henryqw/pi-auto-compact
 ```
 
-`test:live` uses real Pi plus authenticated model access. It disables Pi's built-in auto-compaction, sets a temporary 12K context window, sends a large prompt, and verifies extension compaction, automatic resume, persisted resume message, and assistant response. Set `PI_AUTO_COMPACT_AUTH_FILE` when auth is not at `~/.pi/agent/auth.json`.
+`test:live` needs real Pi plus authenticated model access. Set `PI_AUTO_COMPACT_AUTH_FILE` when auth is not at `~/.pi/agent/auth.json`.
+
+```bash
+npm run test:live --workspace @henryqw/pi-auto-compact
+```

package/extensions/auto-compact.ts

@@ -1,6 +1,7 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import {
+	compact,
 	estimateTokens,
 	getAgentDir,
 	SettingsManager,
@@ -9,6 +10,12 @@ import type {
 	ExtensionAPI,
 	ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
+import {
+	orderedProfileRoutes,
+	readTaskModelsConfig,
+	resolveTaskModelRoute,
+	type ResolvedTaskRoute,
+} from "@henryqw/pi-task-models";
 
 type AgentMessage = Parameters<typeof estimateTokens>[0];
 
@@ -24,13 +31,19 @@ type AgentMessage = Parameters<typeof estimateTokens>[0];
  */
 const DEFAULT_COMPACT_THRESHOLD_PERCENT = 50;
 const MIN_COMPACT_THRESHOLD_PERCENT = 25;
+const AUTO_COMPACT_TASK = "pi-auto-compact/autoCompact";
+const DEFAULT_AUTO_COMPACT_PROFILE = "balanced" as const;
 const configPath = () => join(getAgentDir(), "config", "pi-auto-compact.json");
 
+type Config = {
+	autoCompactThreshold: number;
+};
+
 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 } {
+function readConfig(): Config {
 	let value: unknown;
 	try {
 		value = JSON.parse(readFileSync(configPath(), "utf8"));
@@ -50,14 +63,46 @@ function readConfig(): { autoCompactThreshold: number } {
 	return { autoCompactThreshold: threshold };
 }
 
-function writeConfig(autoCompactThreshold: number): void {
+function writeConfig(config: Config): void {
 	const file = configPath();
 	mkdirSync(dirname(file), { recursive: true });
-	writeFileSync(file, `${JSON.stringify({ autoCompactThreshold }, null, 2)}\n`);
+	writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+}
+
+function configuredTaskRoutes(ctx: ExtensionContext): ResolvedTaskRoute[] | undefined {
+	let config;
+	try {
+		config = readTaskModelsConfig();
+	} catch {
+		ctx.ui.notify("Couldn't read task model config; using current session model.", "error");
+		return undefined;
+	}
+
+	const profileName = config.tasks[AUTO_COMPACT_TASK] ?? DEFAULT_AUTO_COMPACT_PROFILE;
+	const profile = config.profiles[profileName];
+	if (!profile) {
+		ctx.ui.notify(`Task model profile ${profileName} is not configured; using current session model.`, "error");
+		return [];
+	}
+
+	const routes = orderedProfileRoutes(profile)
+		.map((route) => resolveTaskModelRoute(ctx, route))
+		.filter((route): route is ResolvedTaskRoute => route !== undefined);
+	if (!routes.length) {
+		ctx.ui.notify(`No usable ${profileName} task model route; using current session model.`, "error");
+	}
+	return routes;
+}
+
+function withoutDeletedHeaders(headers: Record<string, string | null> | undefined): Record<string, string> | undefined {
+	return headers
+		? Object.fromEntries(Object.entries(headers).filter((entry): entry is [string, string] => entry[1] !== null))
+		: undefined;
 }
 
 // Emergency context guard keeps recent messages while default compaction runs.
 const KEEP_RECENT_PERCENT = 15;
+const COMPACTION_INSTRUCTIONS = "Preserve current task to be resumed after compaction.";
 const RESUME_MESSAGE = "Auto-compact ran. Continue the current task.";
 const COMPACTION_ABORT_ERROR = "This operation was aborted";
 const ACTIVATION_ERROR =
@@ -127,6 +172,7 @@ export default function (pi: ExtensionAPI) {
 	const runCompaction = (ctx: ExtensionContext, resumeTask = true) => {
 		compactionAbortExpected = Boolean(ctx.signal && !ctx.signal.aborted);
 		ctx.compact({
+			customInstructions: COMPACTION_INSTRUCTIONS,
 			onComplete: () => {
 				compactionPending = false;
 				compactionAbortExpected = false;
@@ -209,19 +255,24 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.registerCommand("auto-compact", {
-		description: "set automatic compaction threshold",
-		handler: async (_args, ctx) => {
-			let current: number;
+		description: "configure automatic compaction threshold",
+		handler: async (args, ctx) => {
+			if (args.trim()) {
+				ctx.ui.notify("Usage: /auto-compact", "error");
+				return;
+			}
+
+			let config: Config;
 			try {
-				current = readConfig().autoCompactThreshold;
+				config = readConfig();
 			} 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",
+				`Auto-compact threshold (%) · current: ${config.autoCompactThreshold}`,
+				"Enter a number at least 25 and below 100",
 			);
 			if (input === undefined) return;
 
@@ -236,7 +287,7 @@ export default function (pi: ExtensionAPI) {
 			}
 
 			try {
-				writeConfig(threshold);
+				writeConfig({ autoCompactThreshold: threshold });
 			} catch {
 				ctx.ui.notify("Couldn't save pi-auto-compact config.", "error");
 				return;
@@ -264,4 +315,59 @@ export default function (pi: ExtensionAPI) {
 		// Resume/fork can load an already-large session before first turn.
 		if (event.reason === "resume" || event.reason === "fork") compactIfNeeded(ctx);
 	});
+
+	pi.on("session_before_compact", async (event, ctx) => {
+		if (
+			!active ||
+			!compactionPending ||
+			event.customInstructions !== COMPACTION_INSTRUCTIONS
+		) return;
+
+		// Pi omits details from prior extension compactions when preparing next run.
+		const previous = [...event.branchEntries].reverse().find((entry) => entry.type === "compaction");
+		if (previous?.details && typeof previous.details === "object") {
+			const details = previous.details as { readFiles?: unknown; modifiedFiles?: unknown };
+			if (Array.isArray(details.readFiles)) {
+				for (const path of details.readFiles) {
+					if (typeof path === "string") event.preparation.fileOps.read.add(path);
+				}
+			}
+			if (Array.isArray(details.modifiedFiles)) {
+				for (const path of details.modifiedFiles) {
+					if (typeof path === "string") event.preparation.fileOps.edited.add(path);
+				}
+			}
+		}
+
+		const routes = configuredTaskRoutes(ctx);
+		if (!routes?.length) return;
+
+		for (const route of routes) {
+			try {
+				const auth = await ctx.modelRegistry.getApiKeyAndHeaders(route.model);
+				if (!auth.ok) continue;
+
+				const requestModel = auth.baseUrl ? { ...route.model, baseUrl: auth.baseUrl } : route.model;
+				return {
+					compaction: await compact(
+						event.preparation,
+						requestModel,
+						auth.apiKey,
+						withoutDeletedHeaders(auth.headers),
+						event.customInstructions,
+						event.signal,
+						route.thinkingLevel,
+						undefined,
+						auth.env,
+					),
+				};
+			} catch {
+				if (event.signal.aborted) return;
+			}
+		}
+
+		if (!event.signal.aborted) {
+			ctx.ui.notify("Configured task model routes failed; using current session model.", "error");
+		}
+	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-auto-compact",
-  "version": "0.2.2",
+  "version": "1.0.1",
   "description": "Proactively compact Pi context at a configurable threshold and resume the current task.",
   "keywords": [
     "pi-package",
@@ -25,7 +25,8 @@
     "pack:check": "npm pack --dry-run"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*"
+    "@earendil-works/pi-ai": "^0.84.2",
+    "@earendil-works/pi-coding-agent": "^0.84.2"
   },
   "repository": {
     "type": "git",
@@ -42,5 +43,8 @@
     "extensions": [
       "./extensions"
     ]
+  },
+  "dependencies": {
+    "@henryqw/pi-task-models": "^0.1.0"
   }
 }