feat: auto prune

Author: spoons-and-mirrors

index.ts

@@ -8,7 +8,11 @@ import {
   createChatMessageTransformHandler,
   createEventHandler,
 } from "./lib/hooks";
-import { getPendingPrune, setPendingPrune } from "./lib/ui/confirmation";
+import {
+  getPendingPrune,
+  setPendingPrune,
+  setAutoConfirm,
+} from "./lib/ui/confirmation";
 
 const plugin: Plugin = (async (ctx) => {
   const config = getConfig(ctx);
@@ -103,6 +107,13 @@ const plugin: Plugin = (async (ctx) => {
                   bg: "backgroundPanel",
                   onConfirm: "cancel-prune",
                 },
+                {
+                  type: "confirm-button",
+                  label: " Auto ",
+                  fg: "background",
+                  bg: "warning",
+                  onConfirm: "auto-prune",
+                },
                 {
                   type: "confirm-button",
                   label: " Confirm ",
@@ -137,6 +148,14 @@ const plugin: Plugin = (async (ctx) => {
         } else if (event.event === "cancel-prune" && pending) {
           pending.resolve([]);
           setPendingPrune(null);
+        } else if (event.event === "auto-prune" && pending) {
+          // Enable auto-confirm and confirm this one
+          setAutoConfirm(true);
+          const confirmed = pending.items
+            .filter((i: { checked: boolean }) => i.checked)
+            .map((i: { id: string }) => i.id);
+          pending.resolve(confirmed);
+          setPendingPrune(null);
         }
       }
     },
@@ -179,7 +198,14 @@ const plugin: Plugin = (async (ctx) => {
         );
       }
     },
-    event: createEventHandler(ctx.client, config, state, logger, ctx.directory),
+    event: createEventHandler(
+      ctx.client,
+      config,
+      state,
+      logger,
+      ctx.directory,
+      () => setAutoConfirm(false),
+    ),
   };
 }) satisfies Plugin;
 

lib/hooks.ts

@@ -1,74 +1,77 @@
-import type { SessionState, WithParts } from "./state"
-import type { Logger } from "./logger"
-import type { PluginConfig } from "./config"
-import { syncToolCache } from "./state/tool-cache"
-import { deduplicate, supersedeWrites } from "./strategies"
-import { prune, insertPruneToolContext } from "./messages"
-import { checkSession } from "./state"
-import { runOnIdle } from "./strategies/on-idle"
-
+import type { SessionState, WithParts } from "./state";
+import type { Logger } from "./logger";
+import type { PluginConfig } from "./config";
+import { syncToolCache } from "./state/tool-cache";
+import { deduplicate, supersedeWrites } from "./strategies";
+import { prune, insertPruneToolContext } from "./messages";
+import { checkSession } from "./state";
+import { runOnIdle } from "./strategies/on-idle";
 
 export function createChatMessageTransformHandler(
-    client: any,
-    state: SessionState,
-    logger: Logger,
-    config: PluginConfig
+  client: any,
+  state: SessionState,
+  logger: Logger,
+  config: PluginConfig,
 ) {
-    return async (
-        input: {},
-        output: { messages: WithParts[] }
-    ) => {
-        await checkSession(client, state, logger, output.messages)
+  return async (input: {}, output: { messages: WithParts[] }) => {
+    await checkSession(client, state, logger, output.messages);
 
-        if (state.isSubAgent) {
-            return
-        }
+    if (state.isSubAgent) {
+      return;
+    }
 
-        syncToolCache(state, config, logger, output.messages);
+    syncToolCache(state, config, logger, output.messages);
 
-        deduplicate(state, logger, config, output.messages)
-        supersedeWrites(state, logger, config, output.messages)
+    deduplicate(state, logger, config, output.messages);
+    supersedeWrites(state, logger, config, output.messages);
 
-        prune(state, logger, config, output.messages)
+    prune(state, logger, config, output.messages);
 
-        insertPruneToolContext(state, config, logger, output.messages)
-    }
+    insertPruneToolContext(state, config, logger, output.messages);
+  };
 }
 
 export function createEventHandler(
-    client: any,
-    config: PluginConfig,
-    state: SessionState,
-    logger: Logger,
-    workingDirectory?: string
+  client: any,
+  config: PluginConfig,
+  state: SessionState,
+  logger: Logger,
+  workingDirectory?: string,
+  onUserMessage?: () => void,
 ) {
-    return async (
-        { event }: { event: any }
-    ) => {
-        if (state.sessionId === null || state.isSubAgent) {
-            return
-        }
+  return async ({ event }: { event: any }) => {
+    if (state.sessionId === null || state.isSubAgent) {
+      return;
+    }
+
+    // Reset auto-confirm on user message
+    if (
+      event.type === "message.part.added" &&
+      event.properties?.part?.type === "text"
+    ) {
+      const role = event.properties?.role;
+      if (role === "user" && onUserMessage) {
+        onUserMessage();
+      }
+    }
 
-        if (event.type === "session.status" && event.properties.status.type === "idle") {
-            if (!config.strategies.onIdle.enabled) {
-                return
-            }
-            if (state.lastToolPrune) {
-                logger.info("Skipping OnIdle pruning - last tool was prune")
-                return
-            }
+    if (
+      event.type === "session.status" &&
+      event.properties.status.type === "idle"
+    ) {
+      if (!config.strategies.onIdle.enabled) {
+        return;
+      }
+      if (state.lastToolPrune) {
+        logger.info("Skipping OnIdle pruning - last tool was prune");
+        return;
+      }
 
-            try {
-                await runOnIdle(
-                    client,
-                    state,
-                    logger,
-                    config,
-                    workingDirectory
-                )
-            } catch (err: any) {
-                logger.error("OnIdle pruning failed", { error: err.message })
-            }
-        }
+      try {
+        await runOnIdle(client, state, logger, config, workingDirectory);
+      } catch (err: any) {
+        logger.error("OnIdle pruning failed", { error: err.message });
+      }
     }
+  };
 }

lib/ui/confirmation.ts

@@ -11,6 +11,9 @@ export interface PendingConfirmation {
 // Shared state for pending confirmations
 let pendingPrune: PendingConfirmation | null = null;
 
+// Auto-confirm mode - when true, automatically confirms all prunes
+let autoConfirmEnabled = false;
+
 export function getPendingPrune(): PendingConfirmation | null {
   return pendingPrune;
 }
@@ -19,6 +22,14 @@ export function setPendingPrune(pending: PendingConfirmation | null): void {
   pendingPrune = pending;
 }
 
+export function isAutoConfirmEnabled(): boolean {
+  return autoConfirmEnabled;
+}
+
+export function setAutoConfirm(enabled: boolean): void {
+  autoConfirmEnabled = enabled;
+}
+
 export function resolvePendingPrune(confirmedIds: string[]): void {
   if (pendingPrune) {
     pendingPrune.resolve(confirmedIds);
@@ -29,6 +40,7 @@ export function resolvePendingPrune(confirmedIds: string[]): void {
 /**
  * Shows a confirmation UI for pruning and returns a Promise that resolves
  * with the list of confirmed tool IDs (or empty array if cancelled).
+ * If auto-confirm is enabled, immediately returns all IDs without showing UI.
  */
 export async function requestPruneConfirmation(
   client: any,
@@ -39,6 +51,12 @@ export async function requestPruneConfirmation(
   logger: Logger,
   workingDirectory: string,
 ): Promise<string[]> {
+  // If auto-confirm is enabled, immediately return all IDs
+  if (autoConfirmEnabled) {
+    logger.info("Auto-confirming prune", { itemCount: pruneToolIds.length });
+    return pruneToolIds;
+  }
+
   // Build checklist items from the tool metadata
   const items = pruneToolIds.map((id) => {
     const meta = toolMetadata.get(id);