pi-ui-extend 0.1.36 → 0.1.38

package/external/pi-tools-suite/src/comment-checker/index.ts

@@ -0,0 +1,294 @@
+import { readFile } from "node:fs/promises";
+import { isAbsolute, relative } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { parseApplyPatch } from "../model-tools/apply-patch.js";
+import { detectSlopComments, type CommentFinding, type Edit, type Strictness } from "./detect.js";
+import { loadCommentCheckerConfig } from "./config.js";
+
+type ExtensionContext = import("@earendil-works/pi-coding-agent").ExtensionContext;
+
+/**
+ * comment-checker: AI-slop comment guard.
+ *
+ * Listens to the pi "tool_result" event for write/edit/apply_patch/ast_apply
+ * mutation tools, extracts the net-new comment lines the agent just added,
+ * classifies them, and appends a nudge to the tool result when they look
+ * unnecessary so the agent removes them on their next turn.
+ *
+ * Adapted from oh-my-opencode's comment-checker hook, but pure-TypeScript and
+ * headless (no external binary, no pending-calls machinery: pi's tool_result
+ * event already carries both the input and the result in one call).
+ *
+ * Per-session deduplication mirrors oh-my-opencode: at most one nudge per
+ * session within DEDUP_WINDOW_MS, to prevent a fix/remark loop.
+ */
+
+const DEDUP_WINDOW_MS = 30_000;
+const MAX_FINDINGS = 8;
+
+const MUTATION_TOOL_NAMES = new Set(["write", "edit", "apply_patch", "ast_apply", "multiedit"]);
+
+interface CommentCheckerOptions {
+	strictness: Strictness;
+	enabled: boolean;
+}
+
+function loadOptions(ctx: ExtensionContext): CommentCheckerOptions {
+	const config = loadCommentCheckerConfig(ctx.cwd);
+	return { strictness: config.strictness, enabled: config.enabled };
+}
+
+function asString(value: unknown): string | undefined {
+	return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function asStringArray(value: unknown): readonly string[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	const out = value.filter((item): item is string => typeof item === "string");
+	return out.length > 0 ? out : undefined;
+}
+
+function splitLines(text: string | undefined): readonly string[] {
+	if (text === undefined) return [];
+	return text.split(/\r?\n/);
+}
+
+function editsFromWrite(input: Record<string, unknown>): Edit[] {
+	const filePath = asString(input.file_path) ?? asString(input.path);
+	const content = asString(input.content);
+	if (!filePath || content === undefined) return [];
+	// Full-file write: the added lines start at line 1 of the new file.
+	return [{ filePath, removedLines: [], addedLines: splitLines(content), baseLineNumber: 1 }];
+}
+
+function editsFromEdit(input: Record<string, unknown>): Edit[] {
+	const filePath = asString(input.file_path) ?? asString(input.path);
+	if (!filePath) return [];
+
+	// Claude/GLM alias shape: { old_string, new_string }.
+	const oldString = asString(input.old_string) ?? asString(input.oldString);
+	const newString = asString(input.new_string) ?? asString(input.newString);
+	if (oldString !== undefined || newString !== undefined) {
+		return [{ filePath, removedLines: splitLines(oldString), addedLines: splitLines(newString) }];
+	}
+
+	// Pi builtin edit shape: { edits: [{ oldText, newText }] }.
+	const editsArray = asStringArray(input.edits) ?? input.edits;
+	if (Array.isArray(editsArray)) {
+		const removed: string[] = [];
+		const added: string[] = [];
+		for (const item of editsArray) {
+			if (item && typeof item === "object") {
+				const rec = item as Record<string, unknown>;
+				const o = asString(rec.oldText) ?? asString(rec.old_string);
+				const n = asString(rec.newText) ?? asString(rec.new_string);
+				removed.push(...splitLines(o));
+				added.push(...splitLines(n));
+			}
+		}
+		if (added.length > 0 || removed.length > 0) {
+			return [{ filePath, removedLines: removed, addedLines: added }];
+		}
+	}
+
+	return [];
+}
+
+function editsFromApplyPatch(input: Record<string, unknown>): Edit[] {
+	const patch = asString(input.input) ?? asString(input.patch) ?? asString(input.command);
+	if (!patch) return [];
+
+	let operations: ReturnType<typeof parseApplyPatch> = [];
+	try {
+		operations = parseApplyPatch(patch);
+	} catch {
+		return [];
+	}
+
+	const edits: Edit[] = [];
+	for (const op of operations) {
+		if (op.kind === "delete") continue;
+		if (op.kind === "add") {
+			// Add File creates a new file; added lines start at line 1.
+			edits.push({ filePath: op.path, removedLines: [], addedLines: op.lines, baseLineNumber: 1 });
+			continue;
+		}
+		// update: reconstruct added/removed lines from hunks.
+		const removed: string[] = [];
+		const added: string[] = [];
+		for (const hunk of op.hunks) {
+			for (const line of hunk.lines) {
+				if (line.kind === "remove") removed.push(line.text);
+				else if (line.kind === "add") added.push(line.text);
+			}
+		}
+		if (added.length > 0 || removed.length > 0) {
+			edits.push({ filePath: op.moveTo ?? op.path, removedLines: removed, addedLines: added });
+		}
+	}
+	return edits;
+}
+
+function editsFromAstApply(details: unknown): Edit[] {
+	void details;
+	// ast_apply does not expose per-file diffs cheaply in details; the caller
+	// would have to re-read. Skip diffing here and rely on write/edit/apply_patch.
+	return [];
+}
+
+function extractEdits(toolName: string, input: Record<string, unknown>, details: unknown): Edit[] {
+	const base = toolName.includes(".") ? toolName.split(".").pop() ?? toolName : toolName;
+	const lower = base.toLowerCase();
+
+	if (lower === "write") return editsFromWrite(input);
+	if (lower === "edit" || lower === "multiedit") return editsFromEdit(input);
+	if (lower === "apply_patch") return editsFromApplyPatch(input);
+	if (lower === "ast_apply") return editsFromAstApply(details);
+	return [];
+}
+
+function isMutationTool(toolName: string): boolean {
+	const base = toolName.includes(".") ? toolName.split(".").pop() ?? toolName : toolName;
+	return MUTATION_TOOL_NAMES.has(base.toLowerCase());
+}
+
+/**
+ * Resolve absolute line numbers for edits that do not already know them
+ * (edit / apply_patch update hunks) by reading the already-written file and
+ * locating the start of the added block. write / Add File already carry
+ * baseLineNumber=1 and are skipped.
+ */
+async function resolveBaseLineNumbers(edits: readonly Edit[]): Promise<void> {
+	for (const edit of edits) {
+		if (edit.baseLineNumber !== undefined) continue;
+		if (edit.addedLines.length === 0) continue;
+		edit.baseLineNumber = await findBlockStartLine(edit.filePath, edit.addedLines);
+	}
+}
+
+/**
+ * Find the 1-based line number where `addedLines` begins in the target file.
+ * Matches the leading non-empty lines of `addedLines` against the file; returns
+ * undefined if the file cannot be read or the block is not found.
+ */
+async function findBlockStartLine(filePath: string, addedLines: readonly string[]): Promise<number | undefined> {
+	let raw: string;
+	try {
+		raw = await readFile(filePath, "utf8");
+	} catch {
+		return undefined;
+	}
+	const fileLines = raw.split(/\r?\n/);
+
+	// Anchor: up to 3 leading non-empty added lines.
+	const anchor: string[] = [];
+	for (const line of addedLines) {
+		if (line.trim().length === 0) {
+			if (anchor.length === 0) continue;
+			break;
+		}
+		anchor.push(line);
+		if (anchor.length >= 3) break;
+	}
+	if (anchor.length === 0) return undefined;
+
+	for (let i = 0; i + anchor.length <= fileLines.length; i++) {
+		let match = true;
+		for (let j = 0; j < anchor.length; j++) {
+			if (fileLines[i + j] !== anchor[j]) {
+				match = false;
+				break;
+			}
+		}
+		if (match) return i + 1;
+	}
+	return undefined;
+}
+
+const REASON_TAGS: Record<string, string> = {
+	"restate-code": "restate",
+	filler: "filler",
+	decorative: "decorative",
+	"generic-explanation": "generic",
+	"non-essential-comment": "slop",
+};
+
+/** Render a display path: relative when inside cwd, otherwise the raw path. */
+function displayPath(filePath: string, cwd: string): string {
+	if (isAbsolute(filePath)) {
+		const rel = relative(cwd, filePath);
+		if (rel && !rel.startsWith("..") && !isAbsolute(rel)) return rel;
+	}
+	return filePath;
+}
+
+function formatNudge(findings: CommentFinding[], cwd: string): string {
+	// Group by display path, preserving first-seen order.
+	const groups = new Map<string, CommentFinding[]>();
+	const order: string[] = [];
+	for (const finding of findings) {
+		const key = displayPath(finding.filePath, cwd);
+		const bucket = groups.get(key);
+		if (bucket) bucket.push(finding);
+		else {
+			groups.set(key, [finding]);
+			order.push(key);
+		}
+	}
+
+	// Compact: one line per file. Each finding is `line:tag` (no comment text —
+	// the file already contains it, and the path+line locate it exactly). This
+	// keeps the nudge token-light while preserving location + failure category.
+	const out: string[] = [];
+	out.push("");
+	out.push("---");
+	out.push("💬 comment-checker — unnecessary comments at the lines below (line:reason). Remove any that only restate code / are filler; keep intent, contracts, rationale, TODO.");
+	out.push("");
+	for (const key of order) {
+		const entries = (groups.get(key) ?? []).map((finding) => {
+			const tag = REASON_TAGS[finding.reason] ?? finding.reason;
+			return finding.line !== undefined ? `${finding.line}:${tag}` : `?:${tag}`;
+		});
+		out.push(`${key}  ${entries.join(" ")}`);
+	}
+	out.push("");
+	out.push("---");
+	return out.join("\n");
+}
+
+/** Shared mutable state (module-scoped, like lsp's global manager). */
+let lastNudgeTimestamp = 0;
+
+export function __resetCommentCheckerState(): void {
+	lastNudgeTimestamp = 0;
+}
+
+export default function commentCheckerExtension(pi: ExtensionAPI): void {
+	pi.on("tool_result", async (event, ctx) => {
+		if (event.isError) return undefined;
+		if (!isMutationTool(event.toolName)) return undefined;
+
+		const options = loadOptions(ctx);
+		if (!options.enabled) return undefined;
+
+		const edits = extractEdits(event.toolName, event.input, event.details);
+		if (edits.length === 0) return undefined;
+
+		// Resolve absolute line numbers for edit/apply_patch by reading the file
+		// the tool just wrote. Failures are non-fatal: findings just lack a line.
+		await resolveBaseLineNumbers(edits);
+
+		const findings = detectSlopComments(edits, options.strictness, MAX_FINDINGS);
+		if (findings.length === 0) return undefined;
+
+		// Per-session dedup: at most one nudge per DEDUP_WINDOW_MS.
+		const now = Date.now();
+		if (now - lastNudgeTimestamp < DEDUP_WINDOW_MS) return undefined;
+		lastNudgeTimestamp = now;
+
+		const nudge = formatNudge(findings, ctx.cwd);
+		return {
+			content: [...event.content, { type: "text" as const, text: nudge }],
+		};
+	});
+}

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

@@ -4,7 +4,7 @@ import type { DcpState } from "./state.js"
 import { modelKeysFromContext, resolveModelConfig, type DcpConfig } from "./config.js"
 import type { DcpNudgeType } from "./pruner-types.js"
 import { isToolRecordProtected, markToolPruned } from "./pruner.js"
-import { safeGetContextUsage } from "../context-usage.js"
+import { ignoreStaleExtensionContextError, safeGetContextUsage } from "../context-usage.js"
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -54,7 +54,7 @@ function customEntryData(entry: unknown, customType: string): Record<string, unk
   return record.data as Record<string, unknown>
 }
 
-function branchEntries(ctx: ExtensionCommandContext): unknown[] {
+function branchEntries(ctx: ExtensionCommandContext): any[] {
   try {
     const branch = ctx.sessionManager?.getBranch?.()
     return Array.isArray(branch) ? branch : []
@@ -63,6 +63,14 @@ function branchEntries(ctx: ExtensionCommandContext): unknown[] {
   }
 }
 
+async function staleSafe(action: () => void | Promise<void>): Promise<void> {
+  try {
+    await action()
+  } catch (error) {
+    ignoreStaleExtensionContextError(error)
+  }
+}
+
 interface DcpNudgeStats {
   emitted: number
   upgraded: number
@@ -262,7 +270,7 @@ async function handleSweep(
 ): Promise<void> {
   await ctx.waitForIdle()
 
-  const branch = ctx.sessionManager.getBranch()
+  const branch = branchEntries(ctx)
 
   // Build the full set of protected tool names.
   const protectedTools = new Set<string>([
@@ -341,7 +349,9 @@ async function handleSweep(
     }
   }
 
-  ctx.ui.notify(`Swept ${count} tool output${count === 1 ? "" : "s"}`, "info")
+  await staleSafe(() => {
+    ctx.ui.notify(`Swept ${count} tool output${count === 1 ? "" : "s"}`, "info")
+  })
 }
 
 // ---------------------------------------------------------------------------
@@ -495,17 +505,19 @@ function handleRecompress(
 async function handleCompress(pi: ExtensionAPI, ctx: ExtensionCommandContext): Promise<void> {
   await ctx.waitForIdle()
 
-  pi.sendMessage(
-    {
-      customType: "dcp-compress-trigger",
-      content:
-        "Please compress stale conversation sections using the compress tool now.",
-      display: false,
-    },
-    { triggerTurn: true, deliverAs: "followUp" },
-  )
+  await staleSafe(() => {
+    pi.sendMessage(
+      {
+        customType: "dcp-compress-trigger",
+        content:
+          "Please compress stale conversation sections using the compress tool now.",
+        display: false,
+      },
+      { triggerTurn: true, deliverAs: "followUp" },
+    )
 
-  ctx.ui.notify("Triggered compression", "info")
+    ctx.ui.notify("Triggered compression", "info")
+  })
 }
 
 // ---------------------------------------------------------------------------
@@ -588,7 +600,9 @@ export function registerCommands(
             break
         }
       } finally {
-        hooks.onStateChanged?.(ctx)
+        await staleSafe(() => {
+          hooks.onStateChanged?.(ctx)
+        })
       }
     },
   })

package/external/pi-tools-suite/src/dcp/compress-tool.ts

@@ -6,11 +6,13 @@ import { Type } from "typebox"
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
 import type { DcpState } from "./state.js"
 import { modelKeysFromContext, resolveModelConfig, type DcpConfig } from "./config.js"
+import { saveDcpState } from "./state-persistence.js"
 import { clearDcpNudgeAnchors } from "./pruner.js"
 import type { DcpCompressionVisualDetails } from "./ui.js"
 import { normalizeDcpContextUsage } from "./ui.js"
 import { COMPRESS_TOOL_DESCRIPTION } from "../tool-descriptions.js"
 import { safeGetContextUsage } from "../context-usage.js"
+import { summarizeDcpState, writeDcpDebugLog } from "./debug-log.js"
 import {
   createRangeCompressionBlock,
   findCoveredAndPartialBlocks,
@@ -160,73 +162,111 @@ export function registerCompressTool(
       let operationRemovedTokens = 0
       let operationSummaryTokens = 0
 
+      const log = (event: string, details: Record<string, unknown> = {}) =>
+        writeDcpDebugLog(effectiveConfig, event, details, ctx)
+
+      log("compress.request", {
+        toolCallId: _toolCallId,
+        topic: params.topic,
+        ranges: ranges.map((range) => ({ startId: range.startId, endId: range.endId })),
+        messages: messages.map((entry) => ({ messageId: entry.messageId, topic: entry.topic })),
+        state: summarizeDcpState(state),
+      })
+
       if (ranges.length === 0 && messages.length === 0) {
         throw new Error("compress requires at least one ranges[] or messages[] entry")
       }
 
-      const rangePlans: ResolvedRangePlan[] = ranges.map((range) => {
-        const { startId, endId, summary } = range
-
-        // ── Resolve boundary timestamps ──────────────────────────────────
-        const startBoundary = resolveIdToBoundary(startId, "startTimestamp", state)
-        const endBoundary = resolveIdToBoundary(endId, "endTimestamp", state)
-        const startTimestamp = startBoundary.timestamp
-        const endTimestamp = endBoundary.timestamp
-
-        if (startTimestamp > endTimestamp) {
-          throw new Error(
-            `Range start "${startId}" must appear before end "${endId}" in the conversation`,
-          )
-        }
-
-        // ── Validate timestamps are finite ──────────────────────────────
-        if (!Number.isFinite(startTimestamp)) {
-          throw new Error(
-            `Start ID "${startId}" resolved to a non-finite timestamp (${startTimestamp}). ` +
-            `This usually means the referenced message has a corrupted timestamp.`,
-          )
-        }
-        if (!Number.isFinite(endTimestamp)) {
-          throw new Error(
-            `End ID "${endId}" resolved to a non-finite timestamp (${endTimestamp}). ` +
-            `This usually means the referenced message has a corrupted timestamp.`,
-          )
-        }
-
-        return {
-          startId,
-          endId,
-          summary,
-          startTimestamp,
-          endTimestamp,
-          startMessageId: startBoundary.stableId,
-          endMessageId: endBoundary.stableId,
-        }
-      })
+      let rangePlans: ResolvedRangePlan[]
+      try {
+        rangePlans = ranges.map((range) => {
+          const { startId, endId, summary } = range
+
+          // ── Resolve boundary timestamps ──────────────────────────────────
+          const startBoundary = resolveIdToBoundary(startId, "startTimestamp", state)
+          const endBoundary = resolveIdToBoundary(endId, "endTimestamp", state)
+          const startTimestamp = startBoundary.timestamp
+          const endTimestamp = endBoundary.timestamp
+
+          if (startTimestamp > endTimestamp) {
+            throw new Error(
+              `Range start "${startId}" must appear before end "${endId}" in the conversation`,
+            )
+          }
+
+          // ── Validate timestamps are finite ──────────────────────────────
+          if (!Number.isFinite(startTimestamp)) {
+            throw new Error(
+              `Start ID "${startId}" resolved to a non-finite timestamp (${startTimestamp}). ` +
+              `This usually means the referenced message has a corrupted timestamp.`,
+            )
+          }
+          if (!Number.isFinite(endTimestamp)) {
+            throw new Error(
+              `End ID "${endId}" resolved to a non-finite timestamp (${endTimestamp}). ` +
+              `This usually means the referenced message has a corrupted timestamp.`,
+            )
+          }
+
+          return {
+            startId,
+            endId,
+            summary,
+            startTimestamp,
+            endTimestamp,
+            startMessageId: startBoundary.stableId,
+            endMessageId: endBoundary.stableId,
+          }
+        })
 
-      validateNonOverlappingRanges(rangePlans)
+        validateNonOverlappingRanges(rangePlans)
+      } catch (error) {
+        log("compress.resolve_failed", {
+          toolCallId: _toolCallId,
+          error: error instanceof Error ? error.message : String(error),
+          state: summarizeDcpState(state),
+        })
+        throw error
+      }
 
       for (const range of rangePlans) {
-        const anchor = resolveAnchorBoundary(range.endTimestamp, state)
-
-        const created = createRangeCompressionBlock({
-          topic: params.topic,
-          summary: range.summary,
-          startTimestamp: range.startTimestamp,
-          endTimestamp: range.endTimestamp,
-          startMessageId: range.startMessageId,
-          endMessageId: range.endMessageId,
-          anchorTimestamp: anchor.timestamp,
-          anchorMessageId: anchor.stableId,
-          createdByToolCallId: _toolCallId,
-          state,
-          config: effectiveConfig,
-          mode: "range",
-        })
-        const block = created.block
-        newBlockIds.push(block.id)
-        operationRemovedTokens += created.removedTokenEstimate
-        operationSummaryTokens += created.summaryTokenEstimate
+        try {
+          const anchor = resolveAnchorBoundary(range.endTimestamp, state)
+
+          const created = createRangeCompressionBlock({
+            topic: params.topic,
+            summary: range.summary,
+            startTimestamp: range.startTimestamp,
+            endTimestamp: range.endTimestamp,
+            startMessageId: range.startMessageId,
+            endMessageId: range.endMessageId,
+            anchorTimestamp: anchor.timestamp,
+            anchorMessageId: anchor.stableId,
+            createdByToolCallId: _toolCallId,
+            state,
+            config: effectiveConfig,
+            mode: "range",
+          })
+          const block = created.block
+          newBlockIds.push(block.id)
+          operationRemovedTokens += created.removedTokenEstimate
+          operationSummaryTokens += created.summaryTokenEstimate
+          log("compress.range_created", {
+            toolCallId: _toolCallId,
+            range: { startId: range.startId, endId: range.endId },
+            blockId: `b${block.id}`,
+            coveredBlockIds: block.coveredBlockIds ?? [],
+            anchorMessageId: block.anchorMessageId,
+          })
+        } catch (error) {
+          log("compress.range_failed", {
+            toolCallId: _toolCallId,
+            range: { startId: range.startId, endId: range.endId },
+            error: error instanceof Error ? error.message : String(error),
+            state: summarizeDcpState(state),
+          })
+          throw error
+        }
       }
 
       const skippedMessageIssues: MessageSkipIssue[] = []
@@ -329,6 +369,17 @@ export function registerCompressTool(
         }
       }
 
+      if (newBlockIds.length > 0) {
+        await saveDcpState(ctx, state)
+      }
+
+      log("compress.success", {
+        toolCallId: _toolCallId,
+        newBlockIds: newBlockIds.map((id) => `b${id}`),
+        skippedMessages: skippedMessageIssues.length,
+        state: summarizeDcpState(state),
+      })
+
       const usage = normalizeDcpContextUsage(safeGetContextUsage(ctx))
       const operationTokensSaved = Math.max(0, operationRemovedTokens - operationSummaryTokens)
       const itemCount = ranges.length + messages.length

package/external/pi-tools-suite/src/dcp/config.ts

@@ -10,6 +10,10 @@ import { parse as parseJsonc, type ParseError } from "jsonc-parser"
 export interface DcpConfig {
   enabled: boolean
   debug: boolean
+  debugLog?: {
+    maxBytes?: number
+    maxBackups?: number
+  }
   manualMode: {
     enabled: boolean
     automaticStrategies: boolean // run dedup/purge even in manual mode
@@ -90,27 +94,27 @@ const DEFAULT_CONFIG: DcpConfig = {
     automaticStrategies: true,
   },
   compress: {
-    maxContextPercent: 0.55,
-    minContextPercent: 0.20,
+    maxContextPercent: 0.65,
+    minContextPercent: 0.40,
     modelMaxContextPercent: {},
     modelMinContextPercent: {},
     summaryBuffer: true,
-    nudgeFrequency: 1,
-    iterationNudgeThreshold: 4,
+    nudgeFrequency: 2,
+    iterationNudgeThreshold: 8,
     nudgeForce: "soft",
     protectedTools: ["compress", "write", "edit"],
     protectTags: false,
     protectUserMessages: false,
     autoCandidates: {
       enabled: true,
-      minContextPercent: 0.20,
+      minContextPercent: 0.40,
       keepRecentTurns: 1,
       minMessages: 6,
       minTokens: 1500,
     },
     messageMode: {
       enabled: true,
-      minContextPercent: 0.20,
+      minContextPercent: 0.40,
       keepRecentTurns: 1,
       mediumTokens: 500,
       highTokens: 5000,