@dyyz1993/pi-coding-agent 0.74.24 → 0.74.27

package/dist/extensions/claude-hooks-compat/types.ts

@@ -0,0 +1,77 @@
+export interface ClaudeHookConfig {
+	hooks?: Record<string, MatcherGroup[]>;
+	disableAllHooks?: boolean;
+}
+
+export interface MatcherGroup {
+	matcher?: string;
+	hooks: HookHandler[];
+}
+
+export interface HookHandler {
+	type: "command" | "http" | "mcp_tool" | "prompt" | "agent";
+	command?: string;
+	prompt?: string;
+	url?: string;
+	server?: string;
+	tool?: string;
+	input?: Record<string, unknown>;
+	headers?: Record<string, string>;
+	allowedEnvVars?: string[];
+	model?: string;
+	timeout?: number;
+	if?: string;
+	async?: boolean;
+	asyncRewake?: boolean;
+	shell?: "bash" | "powershell";
+	statusMessage?: string;
+	once?: boolean;
+	"x-pi-variables"?: Record<string, string>;
+}
+
+export interface HookStdinData {
+	session_id: string;
+	transcript_path: string;
+	cwd: string;
+	permission_mode: string;
+	hook_event_name: string;
+	tool_name?: string;
+	tool_input?: Record<string, unknown>;
+	tool_use_id?: string;
+	tool_output?: string;
+	agent_type?: string;
+	agent_id?: string;
+	[key: string]: unknown;
+}
+
+export interface HookOutput {
+	exitCode: number;
+	stdout: string;
+	stderr: string;
+	parsed?: HookParsedOutput;
+}
+
+export interface HookParsedOutput {
+	decision?: string;
+	reason?: string;
+	ok?: boolean;
+	continue?: boolean;
+	stopReason?: string;
+	suppressOutput?: boolean;
+	systemMessage?: string;
+	retry?: boolean;
+	hookSpecificOutput?: {
+		hookEventName?: string;
+		permissionDecision?: "allow" | "deny" | "ask" | "defer";
+		permissionDecisionReason?: string;
+		updatedInput?: Record<string, unknown>;
+		modifiedToolInput?: Record<string, unknown>;
+		additionalContext?: string;
+		[key: string]: unknown;
+	};
+}
+
+export interface IfClause {
+	tool: string;
+	pattern: string;
+}

package/dist/extensions/compaction-manager/config.ts

@@ -0,0 +1,47 @@
+export interface CompactionManagerConfig {
+	microcompact: {
+		enabled: boolean;
+		maxAgeMs: number;
+		clearableTools: string[];
+	};
+	sessionMemory: {
+		enabled: boolean;
+		memoryDir: string;
+		minContentLength: number;
+	};
+	reactive: {
+		enabled: boolean;
+		warnPercent: number;
+		forceCompactPercent: number;
+	};
+	contextFold: {
+		enabled: boolean;
+		maxAgeMs: number;
+		keepRecentCount: number;
+		maxSummaryLength: number;
+	};
+}
+
+export const DEFAULT_CONFIG: CompactionManagerConfig = {
+	microcompact: {
+		enabled: true,
+		maxAgeMs: 60 * 60 * 1000,
+		clearableTools: ["read", "bash", "grep", "find", "glob", "webFetch"],
+	},
+	sessionMemory: {
+		enabled: true,
+		memoryDir: ".pi/memory",
+		minContentLength: 50,
+	},
+	reactive: {
+		enabled: true,
+		warnPercent: 75,
+		forceCompactPercent: 90,
+	},
+	contextFold: {
+		enabled: true,
+		maxAgeMs: 30 * 60 * 1000,
+		keepRecentCount: 6,
+		maxSummaryLength: 200,
+	},
+};

package/dist/extensions/compaction-manager/context-fold.ts

@@ -0,0 +1,63 @@
+import type { AgentMessage } from "@dyyz1993/pi-agent-core";
+import type { AssistantMessage, Message, TextContent, ThinkingContent, ToolCall } from "@dyyz1993/pi-ai";
+import type { SessionEntry, SessionMessageEntry } from "@dyyz1993/pi-coding-agent";
+
+export function findFoldableEntries(
+	entries: SessionEntry[],
+	foldedIds: Set<string>,
+	maxAgeMs: number,
+	keepRecentCount: number,
+): SessionMessageEntry[] {
+	const now = Date.now();
+	const messageEntries = entries.filter(
+		(e): e is SessionMessageEntry => e.type === "message" && e.message.role === "assistant",
+	);
+
+	if (messageEntries.length <= keepRecentCount) return [];
+
+	const candidates = messageEntries.slice(0, -keepRecentCount);
+
+	return candidates.filter((entry) => {
+		if (foldedIds.has(entry.id)) return false;
+		const msg = entry.message as AssistantMessage;
+		if (!Array.isArray(msg.content)) return false;
+		const age = now - msg.timestamp;
+		return age >= maxAgeMs;
+	});
+}
+
+export function extractFoldSummary(message: AssistantMessage, maxLength: number): string {
+	if (!Array.isArray(message.content)) return "[folded empty message]";
+
+	const textParts: string[] = [];
+	for (const block of message.content) {
+		if (block.type === "text" && typeof block.text === "string") {
+			textParts.push(block.text);
+		} else if (block.type === "toolCall" && typeof block.name === "string") {
+			textParts.push(`[called ${block.name}]`);
+		} else if (block.type === "thinking") {
+			textParts.push("[thinking]");
+		}
+	}
+
+	const full = textParts.join(" ").replace(/\s+/g, " ").trim();
+	if (!full) return "[folded empty message]";
+
+	if (full.length <= maxLength) return full;
+	return full.slice(0, maxLength).trim() + "...";
+}
+
+export function estimateMessageTokens(message: Message): number {
+	if (!Array.isArray(message.content)) return 0;
+	let total = 0;
+	for (const block of message.content) {
+		if (block.type === "text" && typeof block.text === "string") {
+			total += Math.ceil(block.text.length / 4);
+		} else if (block.type === "thinking" && typeof (block as ThinkingContent).thinking === "string") {
+			total += Math.ceil((block as ThinkingContent).thinking.length / 4);
+		} else {
+			total += 50;
+		}
+	}
+	return total;
+}

package/dist/extensions/compaction-manager/index.ts

@@ -0,0 +1,151 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { ExtensionAPI } from "@dyyz1993/pi-coding-agent";
+import type { AssistantMessage } from "@dyyz1993/pi-ai";
+import { DEFAULT_CONFIG, type CompactionManagerConfig } from "./config.js";
+import { extractFoldSummary, estimateMessageTokens, findFoldableEntries } from "./context-fold.js";
+import { microcompactMessages, stripThinkingBlocks } from "./microcompact.js";
+import { buildMemorySummary, readMemoryFiles } from "./session-memory.js";
+import { shouldWarn, shouldForceCompact } from "./reactive.js";
+
+function loadConfig(): CompactionManagerConfig {
+	const configPath = join(process.cwd(), ".pi", "compaction.json");
+	if (existsSync(configPath)) {
+		try {
+			const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+			return {
+				microcompact: { ...DEFAULT_CONFIG.microcompact, ...raw.microcompact },
+				sessionMemory: { ...DEFAULT_CONFIG.sessionMemory, ...raw.sessionMemory },
+				reactive: { ...DEFAULT_CONFIG.reactive, ...raw.reactive },
+				contextFold: { ...DEFAULT_CONFIG.contextFold, ...raw.contextFold },
+			};
+		} catch (err) {
+			console.debug("[compaction-manager] config load failed:", err instanceof Error ? err.message : err);
+			return DEFAULT_CONFIG;
+		}
+	}
+	return DEFAULT_CONFIG;
+}
+
+export default function (pi: ExtensionAPI) {
+	const config = loadConfig();
+
+	if (config.microcompact.enabled) {
+		pi.on("context", (event, _ctx) => {
+			const microResult = microcompactMessages(event.messages, config.microcompact.clearableTools, config.microcompact.maxAgeMs);
+			const messages = microResult?.messages ?? event.messages;
+			const thinkResult = stripThinkingBlocks(messages);
+			return thinkResult ?? microResult;
+		});
+	} else {
+		pi.on("context", (event, _ctx) => {
+			return stripThinkingBlocks(event.messages);
+		});
+	}
+
+	if (config.contextFold.enabled) {
+		pi.on("turn_end", (_event, ctx) => {
+			const entries = ctx.sessionManager.getBranch();
+
+			const foldedIds = new Set<string>();
+			for (const entry of entries) {
+				if (entry.type === "fold") {
+					foldedIds.add(entry.targetId);
+				}
+			}
+
+			const foldable = findFoldableEntries(
+				entries,
+				foldedIds,
+				config.contextFold.maxAgeMs,
+				config.contextFold.keepRecentCount,
+			);
+
+			if (foldable.length === 0) return;
+
+			for (const entry of foldable) {
+				const msg = entry.message as AssistantMessage;
+				const summary = extractFoldSummary(msg, config.contextFold.maxSummaryLength);
+				const tokens = estimateMessageTokens(msg);
+				pi.foldEntry(entry.id, summary, tokens);
+			}
+
+			ctx.ui.notify(`Context fold: folded ${foldable.length} old message(s)`, "info");
+		});
+	}
+
+	if (config.sessionMemory.enabled) {
+		pi.on("session_before_compact", async (event, ctx) => {
+			const { preparation, signal } = event;
+
+			const memoryFiles = await readMemoryFiles(ctx.cwd, config.sessionMemory.memoryDir);
+			if (memoryFiles.size === 0 || signal.aborted) return;
+
+			const result = buildMemorySummary(memoryFiles, preparation, config.sessionMemory.minContentLength);
+			if (!result) return;
+
+			ctx.ui.notify(
+				`Session Memory Compact: using ${memoryFiles.size} memory files instead of LLM summary`,
+				"info",
+			);
+
+			return { compaction: result };
+		});
+	}
+
+	if (config.reactive.enabled) {
+		let warnedThisTurn = false;
+
+		pi.on("after_provider_response", (event, ctx) => {
+			if (event.status === 429) {
+				ctx.ui.notify("Rate limited — API is throttling requests", "warning");
+			} else if (event.status >= 500) {
+				ctx.ui.notify(`API server error (${event.status}) — will retry automatically`, "warning");
+			}
+		});
+
+		pi.on("turn_end", (_event, ctx) => {
+			const usage = ctx.getContextUsage();
+			if (!usage || usage.tokens === null) return;
+
+			const { tokens, contextWindow, percent } = usage;
+
+			if (shouldForceCompact(tokens, contextWindow, config.reactive.forceCompactPercent) && !warnedThisTurn) {
+				ctx.ui.notify(
+					`Context critical: ${percent!.toFixed(0)}% (${tokens!.toLocaleString()} / ${contextWindow.toLocaleString()} tokens). Consider /compact-force.`,
+					"warning",
+				);
+				warnedThisTurn = true;
+				return;
+			}
+
+			if (shouldWarn(tokens, contextWindow, config.reactive.warnPercent) && !warnedThisTurn) {
+				ctx.ui.notify(
+					`Context high: ${percent!.toFixed(0)}% (${tokens!.toLocaleString()} / ${contextWindow.toLocaleString()} tokens)`,
+					"info",
+				);
+				warnedThisTurn = true;
+			}
+		});
+
+		pi.on("agent_start", () => {
+			warnedThisTurn = false;
+		});
+
+		pi.registerCommand("compact-force", {
+			description: "Force compaction immediately with optional custom instructions",
+			handler: async (args, ctx) => {
+				const instructions = args.trim() || undefined;
+				ctx.compact({
+					customInstructions: instructions,
+					onComplete: (result) => {
+						ctx.ui.notify(`Compaction done: ${result.tokensBefore.toLocaleString()} tokens compressed`, "info");
+					},
+					onError: (error) => {
+						ctx.ui.notify(`Compaction failed: ${error.message}`, "error");
+					},
+				});
+			},
+		});
+	}
+}

package/dist/extensions/compaction-manager/microcompact.ts

@@ -0,0 +1,49 @@
+import type { AgentMessage } from "@dyyz1993/pi-agent-core";
+import type { AssistantMessage, TextContent, ToolResultMessage } from "@dyyz1993/pi-ai";
+
+export function microcompactMessages(
+	messages: AgentMessage[],
+	clearableTools: string[],
+	maxAgeMs: number,
+): { messages: AgentMessage[] } | undefined {
+	const now = Date.now();
+	let modified = false;
+
+	const cleaned = messages.map((msg) => {
+		if (msg.role !== "toolResult") return msg;
+		const toolMsg = msg as ToolResultMessage;
+		if (!clearableTools.includes(toolMsg.toolName)) return msg;
+		if (toolMsg.isError) return msg;
+		if (now - toolMsg.timestamp < maxAgeMs) return msg;
+
+		modified = true;
+		return {
+			...toolMsg,
+			content: [{ type: "text" as const, text: `[Old ${toolMsg.toolName} result cleared]` }],
+		};
+	});
+
+	return modified ? { messages: cleaned } : undefined;
+}
+
+export function stripThinkingBlocks(messages: AgentMessage[]): { messages: AgentMessage[] } | undefined {
+	let modified = false;
+
+	const cleaned = messages.map((msg) => {
+		if (msg.role !== "assistant") return msg;
+		const assistant = msg as AssistantMessage;
+		if (!Array.isArray(assistant.content)) return msg;
+
+		const hasThinking = assistant.content.some((block: AssistantMessage["content"][number]) => block.type === "thinking");
+		if (!hasThinking) return msg;
+
+		modified = true;
+		const filtered = assistant.content.filter((block: AssistantMessage["content"][number]) => block.type !== "thinking");
+		return {
+			...assistant,
+			content: filtered,
+		};
+	});
+
+	return modified ? { messages: cleaned } : undefined;
+}

package/dist/extensions/compaction-manager/reactive.ts

@@ -0,0 +1,9 @@
+export function shouldWarn(tokens: number | null, contextWindow: number, warnPercent: number): boolean {
+	if (tokens === null) return false;
+	return (tokens / contextWindow) * 100 >= warnPercent;
+}
+
+export function shouldForceCompact(tokens: number | null, contextWindow: number, forcePercent: number): boolean {
+	if (tokens === null) return false;
+	return (tokens / contextWindow) * 100 >= forcePercent;
+}

package/dist/extensions/compaction-manager/session-memory.ts

@@ -0,0 +1,48 @@
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import type { CompactionPreparation, CompactionResult } from "@dyyz1993/pi-coding-agent";
+
+export type { CompactionPreparation, CompactionResult };
+
+export function buildMemorySummary(
+	memoryFiles: Map<string, string>,
+	preparation: CompactionPreparation,
+	minContentLength: number,
+): CompactionResult | undefined {
+	if (memoryFiles.size === 0) return undefined;
+
+	const parts: string[] = [];
+	for (const [name, content] of memoryFiles) {
+		parts.push(`### ${name}\n${content}`);
+	}
+	const summary = parts.join("\n\n---\n\n");
+
+	if (summary.trim().length < minContentLength) return undefined;
+
+	const estimatedTokens = Math.ceil(summary.length / 4);
+	if (estimatedTokens > preparation.settings.reserveTokens) return undefined;
+
+	return {
+		summary,
+		firstKeptEntryId: preparation.firstKeptEntryId,
+		tokensBefore: preparation.tokensBefore,
+	};
+}
+
+export async function readMemoryFiles(cwd: string, memoryDir: string): Promise<Map<string, string>> {
+	const dir = join(cwd, memoryDir);
+	const files = new Map<string, string>();
+
+	try {
+		const entries = await readdir(dir);
+		for (const entry of entries) {
+			if (!entry.endsWith(".md")) continue;
+			const content = await readFile(join(dir, entry), "utf-8");
+			files.set(entry, content);
+		}
+	} catch (err) {
+		console.debug("[compaction-manager] session memory dir read failed:", err instanceof Error ? err.message : err);
+	}
+
+	return files;
+}