pi-ui-extend 0.1.1 → 0.1.2

package/bin/pix.mjs

@@ -4,8 +4,8 @@ import { existsSync, readdirSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
-const requiredNodeMajor = 24;
-const launcherPath = fileURLToPath(import.meta.url);
+const minimumNodeVersion = [22, 19, 0];
+const minimumNodeVersionLabel = "22.19.0";
 const mainPath = fileURLToPath(new URL("../dist/main.js", import.meta.url));
 const updatePath = fileURLToPath(new URL("../dist/app/update.js", import.meta.url));
 const distPath = dirname(mainPath);
@@ -13,8 +13,10 @@ const rawArgs = process.argv.slice(2);
 const childArgs = [];
 let reloadOnBuild = truthyEnv(process.env.PIX_RELOAD_ON_BUILD);
 
-if (currentNodeMajor() !== requiredNodeMajor && process.env.PIX_NODE24_REEXEC !== "1") {
-	await reexecWithNode24(rawArgs);
+if (!isCurrentNodeSupported()) {
+	console.error(`[pix] Node ${minimumNodeVersionLabel}+ is required; current Node is ${process.versions.node}.`);
+	console.error("[pix] Install/use a newer Node, for example `mise install node@22.19.0` or `nvm install 22`.");
+	process.exit(1);
 }
 
 for (const arg of rawArgs) {
@@ -66,52 +68,15 @@ function truthyEnv(value) {
 	return !["0", "false", "no", "off"].includes(value.toLowerCase());
 }
 
-function currentNodeMajor() {
-	return Number.parseInt(process.versions.node.split(".")[0] ?? "", 10);
-}
-
-async function reexecWithNode24(args) {
-	console.error(`[pix] switching from Node ${process.versions.node} to Node 24.16.0`);
-	const candidates = node24Candidates(args);
-
-	for (const candidate of candidates) {
-		const result = await runNode24Candidate(candidate.command, candidate.args);
-		if (!result.launched) continue;
-		if (result.signal) process.exitCode = result.signal === "SIGINT" ? 130 : result.signal === "SIGTERM" ? 143 : 1;
-		else process.exitCode = result.code ?? 1;
-		process.exit();
+function isCurrentNodeSupported() {
+	const parts = process.versions.node.split(".").map((part) => Number.parseInt(part, 10));
+	for (let index = 0; index < minimumNodeVersion.length; index += 1) {
+		const current = parts[index] ?? 0;
+		const minimum = minimumNodeVersion[index];
+		if (current > minimum) return true;
+		if (current < minimum) return false;
 	}
-
-	console.error("[pix] Node 24 is required. Install/use it with `mise install node@24.16.0` or set PIX_NODE24=/path/to/node24.");
-	process.exit(1);
-}
-
-function node24Candidates(args) {
-	const envNode = process.env.PIX_NODE24;
-	return [
-		...(envNode ? [{ command: envNode, args: [launcherPath, ...args] }] : []),
-		{ command: "mise", args: ["exec", "node@24.16.0", "--", "node", launcherPath, ...args] },
-		{ command: "node24", args: [launcherPath, ...args] },
-		{ command: "node-24", args: [launcherPath, ...args] },
-	];
-}
-
-async function runNode24Candidate(command, args) {
-	return await new Promise((resolve) => {
-		const child = spawn(command, args, {
-			stdio: "inherit",
-			env: { ...process.env, PIX_NODE24_REEXEC: "1" },
-		});
-
-		child.once("error", (error) => {
-			if (error && error.code === "ENOENT") resolve({ launched: false });
-			else {
-				console.error(error?.message ?? String(error));
-				resolve({ launched: true, code: 1 });
-			}
-		});
-		child.once("exit", (code, signal) => resolve({ launched: true, code, signal }));
-	});
+	return true;
 }
 
 function startChild() {

package/external/pi-tools-suite/src/compress/commands.ts

@@ -2,6 +2,7 @@ import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-cod
 import type { AutocompleteItem } from "@mariozechner/pi-tui"
 import type { DcpState } from "./state.js"
 import type { DcpConfig } from "./config.js"
+import type { DcpNudgeType } from "./pruner-types.js"
 import { isToolRecordProtected, markToolPruned } from "./pruner.js"
 import { safeGetContextUsage } from "../context-usage.js"
 
@@ -11,6 +12,8 @@ import { safeGetContextUsage } from "../context-usage.js"
 
 /** Tools whose outputs are always protected from sweep regardless of config. */
 const ALWAYS_PROTECTED_TOOLS = ["compress", "write", "edit"] as const
+export const DCP_STATS_MESSAGE_TYPE = "pix-system"
+const DCP_STATS_DETAILS_KIND = "dcp-stats"
 
 export interface DcpCommandHooks {
   onStateChanged?: (ctx: ExtensionCommandContext) => void
@@ -24,6 +27,130 @@ function fmt(n: number): string {
   return n.toLocaleString()
 }
 
+const NUDGE_TYPES: DcpNudgeType[] = ["turn", "iteration", "context-soft", "context-strong"]
+
+function pct(numerator: number, denominator: number): string {
+  if (denominator <= 0) return "n/a"
+  return `${((numerator / denominator) * 100).toFixed(1)}%`
+}
+
+function nudgeLabel(type: DcpNudgeType): string {
+  switch (type) {
+    case "context-strong": return "context-strong"
+    case "context-soft": return "context-soft"
+    case "iteration": return "iteration"
+    case "turn": return "turn"
+  }
+}
+
+function isNudgeType(value: unknown): value is DcpNudgeType {
+  return typeof value === "string" && (NUDGE_TYPES as string[]).includes(value)
+}
+
+function customEntryData(entry: unknown, customType: string): Record<string, unknown> | undefined {
+  const record = entry as { type?: unknown; customType?: unknown; data?: unknown }
+  if (record?.type !== "custom" || record.customType !== customType) return undefined
+  if (!record.data || typeof record.data !== "object" || Array.isArray(record.data)) return undefined
+  return record.data as Record<string, unknown>
+}
+
+function branchEntries(ctx: ExtensionCommandContext): unknown[] {
+  try {
+    const branch = ctx.sessionManager?.getBranch?.()
+    return Array.isArray(branch) ? branch : []
+  } catch {
+    return []
+  }
+}
+
+interface DcpNudgeStats {
+  emitted: number
+  upgraded: number
+  clearedEvents: number
+  clearedAnchors: number
+  byType: Record<DcpNudgeType, number>
+  activeByType: Record<DcpNudgeType, number>
+  last?: {
+    type: DcpNudgeType
+    event: "emitted" | "upgraded"
+    createdAt?: number
+    contextPercent?: number | null
+  }
+}
+
+function collectNudgeStats(ctx: ExtensionCommandContext, state: DcpState): DcpNudgeStats {
+  const stats: DcpNudgeStats = {
+    emitted: 0,
+    upgraded: 0,
+    clearedEvents: 0,
+    clearedAnchors: 0,
+    byType: { "turn": 0, "iteration": 0, "context-soft": 0, "context-strong": 0 },
+    activeByType: { "turn": 0, "iteration": 0, "context-soft": 0, "context-strong": 0 },
+  }
+
+  for (const anchor of state.nudgeAnchors) {
+    if (isNudgeType(anchor.type)) stats.activeByType[anchor.type]++
+  }
+
+  for (const entry of branchEntries(ctx)) {
+    const data = customEntryData(entry, "dcp-nudge")
+    if (!data) continue
+    const event = data.event
+    if ((event === "emitted" || event === "upgraded") && isNudgeType(data.type)) {
+      if (event === "emitted") stats.emitted++
+      else stats.upgraded++
+      stats.byType[data.type]++
+      const createdAt = typeof data.createdAt === "number" ? data.createdAt : undefined
+      const contextPercent = typeof data.contextPercent === "number" || data.contextPercent === null
+        ? data.contextPercent
+        : undefined
+      if (!stats.last || (createdAt ?? 0) >= (stats.last.createdAt ?? 0)) {
+        stats.last = { type: data.type, event, createdAt, contextPercent }
+      }
+    } else if (event === "cleared") {
+      stats.clearedEvents++
+      stats.clearedAnchors += typeof data.clearedAnchors === "number" ? Math.max(0, data.clearedAnchors) : 0
+    }
+  }
+
+  if (!stats.last && state.lastNudge && isNudgeType(state.lastNudge.type)) {
+    stats.last = {
+      type: state.lastNudge.type,
+      event: "emitted",
+      createdAt: state.lastNudge.createdAt,
+      contextPercent: typeof state.lastNudge.contextPercent === "number"
+        ? state.lastNudge.contextPercent * 100
+        : undefined,
+    }
+  }
+
+  return stats
+}
+
+function formatDate(ts: number | undefined): string {
+  if (typeof ts !== "number" || !Number.isFinite(ts) || ts <= 0) return "unknown time"
+  return new Date(ts).toLocaleString()
+}
+
+function formatContextPercent(value: number | null | undefined): string {
+  if (value === null) return "unknown context"
+  if (typeof value !== "number" || !Number.isFinite(value)) return "unknown context"
+  return `${value.toFixed(1)}% context`
+}
+
+function sendChatSystemMessage(pi: ExtensionAPI, customType: string, content: string, details?: Record<string, unknown>): void {
+	pi.sendMessage({
+		customType,
+		content,
+		display: true,
+		details: {
+			kind: DCP_STATS_DETAILS_KIND,
+			userVisibleOnly: true,
+			...(details ?? {}),
+		},
+	})
+}
+
 // ---------------------------------------------------------------------------
 // Help
 // ---------------------------------------------------------------------------
@@ -83,17 +210,44 @@ function handleContext(ctx: ExtensionCommandContext, state: DcpState): void {
 // Stats
 // ---------------------------------------------------------------------------
 
-function handleStats(ctx: ExtensionCommandContext, state: DcpState): void {
+function handleStats(pi: ExtensionAPI, ctx: ExtensionCommandContext, state: DcpState): void {
   const activeBlocks = state.compressionBlocks.filter((b) => b.active).length
   const totalBlocks = state.compressionBlocks.length
+  const nudgeStats = collectNudgeStats(ctx, state)
+  const totalNudgeEvents = nudgeStats.emitted + nudgeStats.upgraded
+  const activeAnchors = state.nudgeAnchors.length
   const lines: string[] = []
   lines.push("DCP Session Statistics:")
   lines.push(`  Tokens saved (estimated): ${fmt(state.tokensSaved)}`)
   lines.push(`  Total pruning operations: ${fmt(state.totalPruneCount)}`)
   lines.push(`  Compression blocks active: ${activeBlocks} / ${totalBlocks} total`)
   lines.push(`  Manual mode: ${state.manualMode ? "on" : "off"}`)
+  lines.push("")
+  lines.push("Nudge telemetry:")
+  lines.push(`  Sent: ${fmt(nudgeStats.emitted)} emitted, ${fmt(nudgeStats.upgraded)} upgraded`)
+  lines.push(
+    `  By type: ${NUDGE_TYPES.map((type) => `${nudgeLabel(type)}=${fmt(nudgeStats.byType[type])}`).join(", ")}`,
+  )
+  lines.push(
+    `  Active anchors: ${fmt(activeAnchors)}${activeAnchors > 0
+      ? ` (${NUDGE_TYPES.map((type) => `${nudgeLabel(type)}=${fmt(nudgeStats.activeByType[type])}`).join(", ")})`
+      : ""}`,
+  )
+  lines.push(`  Cleared after compress: ${fmt(nudgeStats.clearedEvents)} time${nudgeStats.clearedEvents === 1 ? "" : "s"} (${fmt(nudgeStats.clearedAnchors)} anchor${nudgeStats.clearedAnchors === 1 ? "" : "s"})`)
+  lines.push(`  Compliance proxy: ${fmt(nudgeStats.clearedEvents)} compress-after-nudge / ${fmt(totalNudgeEvents)} nudge event${totalNudgeEvents === 1 ? "" : "s"} (${pct(nudgeStats.clearedEvents, totalNudgeEvents)})`)
+  if (nudgeStats.last) {
+    lines.push(
+      `  Last nudge: ${nudgeLabel(nudgeStats.last.type)} ${nudgeStats.last.event} at ${formatDate(nudgeStats.last.createdAt)} (${formatContextPercent(nudgeStats.last.contextPercent)})`,
+    )
+  } else {
+    lines.push("  Last nudge: none recorded")
+  }
 
-  ctx.ui.notify(lines.join("\n"), "info")
+  sendChatSystemMessage(pi, DCP_STATS_MESSAGE_TYPE, lines.join("\n"), {
+    generatedAt: new Date().toISOString(),
+    activeAnchors,
+    nudgeEvents: totalNudgeEvents,
+  })
 }
 
 // ---------------------------------------------------------------------------
@@ -399,7 +553,7 @@ export function registerCommands(
             break
 
           case "stats":
-            handleStats(ctx, state)
+            handleStats(pi, ctx, state)
             break
 
           case "sweep": {

package/external/pi-tools-suite/src/compress/index.ts

@@ -36,7 +36,7 @@ import {
 } from "./pruner.js"
 import type { DcpNudgeType } from "./pruner-types.js"
 import { registerCompressTool } from "./compress-tool.js"
-import { registerCommands } from "./commands.js"
+import { DCP_STATS_MESSAGE_TYPE, registerCommands } from "./commands.js"
 import { DcpUiController, normalizeDcpContextUsage } from "./ui.js"
 import { registerTuiFilter } from "./dcp-tui-filter.js"
 import { ignoreStaleExtensionContextError, safeGetContextUsage } from "../context-usage.js"
@@ -89,6 +89,12 @@ function baseNudgeText(type: DcpNudgeType): string {
 	return TURN_NUDGE
 }
 
+function isUserVisibleOnlyMessage(message: any): boolean {
+	if (message?.role !== "custom") return false
+	if (message.customType !== DCP_STATS_MESSAGE_TYPE) return false
+	return message.details?.userVisibleOnly === true
+}
+
 // ---------------------------------------------------------------------------
 // Module export
 // ---------------------------------------------------------------------------
@@ -121,6 +127,7 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 		}
 	}
 	const appendNudgeTelemetry = (
+		event: "emitted" | "upgraded",
 		type: DcpNudgeType,
 		anchor: { id: number; anchorTimestamp: number; anchorStableId?: string; anchorRole: string },
 		usage: ReturnType<typeof normalizeDcpContextUsage>,
@@ -128,7 +135,7 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 	): void => {
 		try {
 			pi.appendEntry("dcp-nudge", {
-				event: "emitted",
+				event,
 				type,
 				label: nudgeTypeLabel(type),
 				anchorId: anchor.id,
@@ -262,8 +269,9 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 
 	// ── 11. context: apply pruning and inject nudges ──────────────────────────
 	pi.on("context", async (event, ctx) => {
-		annotateMessagesWithBranchEntryIds(event.messages, ctx)
-		let prunedMessages = applyPruning(event.messages, state, config)
+		const contextMessages = event.messages.filter((message: any) => !isUserVisibleOnlyMessage(message))
+		annotateMessagesWithBranchEntryIds(contextMessages, ctx)
+		let prunedMessages = applyPruning(contextMessages, state, config)
 		let candidate = null as ReturnType<typeof detectCompressionCandidate>
 		let messageCandidates = [] as ReturnType<typeof detectMessageCompressionCandidates>
 
@@ -350,7 +358,13 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 				)
 				if (anchorResult.anchor) {
 					if (anchorResult.updated) {
-						appendNudgeTelemetry(nudgeType, anchorResult.anchor, usage, toolCallsSinceLastUser)
+						appendNudgeTelemetry(
+							anchorResult.created ? "emitted" : "upgraded",
+							nudgeType,
+							anchorResult.anchor,
+							usage,
+							toolCallsSinceLastUser,
+						)
 						saveState(pi, state)
 					}
 				} else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "private": false,
   "type": "module",
   "bin": {
@@ -70,7 +70,7 @@
     "typescript": "5.9.3"
   },
   "engines": {
-    "node": ">=24 <25"
+    "node": ">=22.19.0 <25"
   },
   "overrides": {
     "get-uv-event-loop-napi-h": "1.0.6",