Merge pull request #261 from acunniffe/fix/human-cli-checkpoint-output

improve performance of git-ai checkpoint for 1000+ file human checkpoints

Author: svarlamov

agent-support/vscode/src/ai-edit-manager.ts

@@ -8,7 +8,7 @@ export class AIEditManager {
   private workspaceBaseStoragePath: string | null = null;
   private gitAiVersion: string | null = null;
   private hasShownGitAiErrorMessage = false;
-  private lastHumanCheckpointAt: Date | null = null;
+  private lastHumanCheckpointAt = new Map<string, number>();
   private pendingSaves = new Map<string, {
     timestamp: number;
     timer: NodeJS.Timeout;
@@ -20,6 +20,9 @@ export class AIEditManager {
   }>();
   private readonly SAVE_EVENT_DEBOUNCE_WINDOW_MS = 300;
   private readonly HUMAN_CHECKPOINT_DEBOUNCE_MS = 500;
+  private readonly HUMAN_CHECKPOINT_CLEANUP_INTERVAL_MS = 60000; // 1 minute
+  private readonly MAX_SNAPSHOT_AGE_MS = 10_000; // 10 seconds; used to avoid triggering AI checkpoints on stale snapshots
+  private cleanupTimer: NodeJS.Timeout;
 
   constructor(context: vscode.ExtensionContext) {
     if (context.storageUri?.fsPath) {
@@ -28,6 +31,39 @@ export class AIEditManager {
       // No workspace active (extension will be re-activated when a workspace is opened)
       console.warn('[git-ai] No workspace storage URI available');
     }
+
+    // Periodically clean up old entries from lastHumanCheckpointAt to avoid memory leaks
+    this.cleanupTimer = setInterval(() => {
+      this.cleanupOldCheckpointEntries();
+    }, this.HUMAN_CHECKPOINT_CLEANUP_INTERVAL_MS);
+  }
+
+  public dispose(): void {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+    }
+  }
+
+  private cleanupOldCheckpointEntries(): void {
+    const now = Date.now();
+    const entriesToDelete: string[] = [];
+
+    // Remove entries older than 5 minutes
+    const MAX_AGE_MS = 5 * 60 * 1000;
+
+    this.lastHumanCheckpointAt.forEach((timestamp, filePath) => {
+      if (now - timestamp > MAX_AGE_MS) {
+        entriesToDelete.push(filePath);
+      }
+    });
+
+    entriesToDelete.forEach(filePath => {
+      this.lastHumanCheckpointAt.delete(filePath);
+    });
+
+    if (entriesToDelete.length > 0) {
+      console.log('[git-ai] AIEditManager: Cleaned up', entriesToDelete.length, 'old checkpoint entries');
+    }
   }
 
   public handleSaveEvent(doc: vscode.TextDocument): void {
@@ -53,7 +89,8 @@ export class AIEditManager {
   }
 
   public handleOpenEvent(doc: vscode.TextDocument): void {
-    if (doc.uri.scheme === "chat-editing-snapshot-text-model") {
+    console.log('[git-ai] AIEditManager: Open event detected for', doc);
+    if (doc.uri.scheme === "chat-editing-snapshot-text-model" || doc.uri.scheme === "chat-editing-text-model") {
       const filePath = doc.uri.fsPath;
       const now = Date.now();
 
@@ -69,14 +106,18 @@ export class AIEditManager {
         });
       }
 
-      console.log('[git-ai] AIEditManager: Snapshot open event tracked for', filePath, 'count:', this.snapshotOpenEvents.get(filePath)?.count);
+      // Trigger human checkpoint when whenever we see a snapshot open (before any changes are made -- debounce logic is handled in the triggerHumanCheckpoint method)
+      console.log('[git-ai] AIEditManager: Snapshot open event detected for', filePath, 'scheme:', doc.uri.scheme, 'seen count:', this.snapshotOpenEvents.get(filePath)?.count, '- triggering human checkpoint');
+      this.triggerHumanCheckpoint([filePath]);
     }
   }
 
   public handleCloseEvent(doc: vscode.TextDocument): void {
-    if (doc.uri.scheme === "chat-editing-snapshot-text-model") {
-      console.log('[git-ai] AIEditManager: Snapshot close event detected, triggering human checkpoint');
-      this.checkpoint("human");
+    if (doc.uri.scheme === "chat-editing-snapshot-text-model" || doc.uri.scheme === "chat-editing-text-model") {
+      console.log('[git-ai] AIEditManager: Snapshot close event detected for', doc);
+      // console.log('[git-ai] AIEditManager: Snapshot close event detected, triggering human checkpoint');
+      // const filePath = doc.uri.fsPath;
+      // this.triggerHumanCheckpoint([filePath]);
     }
   }
 
@@ -101,24 +142,29 @@ export class AIEditManager {
     let checkpointTriggered = false;
 
     if (snapshotInfo && snapshotInfo.count >= 1 && snapshotInfo.uri?.query) {
-      const storagePath = this.workspaceBaseStoragePath;
-      if (!storagePath) {
-        console.warn('[git-ai] AIEditManager: Missing workspace storage path, skipping AI checkpoint for', filePath);
+      // Check if the snapshot is fresh to avoid triggering AI checkpoints on stale snapshots
+      const snapshotAge = Date.now() - snapshotInfo.timestamp;
+
+      if (snapshotAge >= this.MAX_SNAPSHOT_AGE_MS) {
+        console.log('[git-ai] AIEditManager: Snapshot is too old (' + Math.round(snapshotAge / 1000) + 's), skipping AI checkpoint for', filePath);
       } else {
-        try {
-          const params = JSON.parse(snapshotInfo.uri.query);
-          const sessionId = params.sessionId;
-          const requestId = params.requestId;
-
-          if (!sessionId || !requestId) {
-            console.warn('[git-ai] AIEditManager: Snapshot URI missing session or request id, skipping AI checkpoint for', filePath);
-          } else {
-            const workspaceFolder = vscode.workspace.getWorkspaceFolder(vscode.Uri.file(filePath));
-            if (!workspaceFolder) {
-              console.warn('[git-ai] AIEditManager: No workspace folder found for', filePath, '- skipping AI checkpoint');
+        const storagePath = this.workspaceBaseStoragePath;
+        if (!storagePath) {
+          console.warn('[git-ai] AIEditManager: Missing workspace storage path, skipping AI checkpoint for', filePath);
+        } else {
+          try {
+            const params = JSON.parse(snapshotInfo.uri.query);
+            const sessionId = params.chatSessionId || params.sessionId;
+
+            if (!sessionId) {
+              console.warn('[git-ai] AIEditManager: Snapshot URI missing session id, skipping AI checkpoint for', filePath);
             } else {
+              const workspaceFolder = vscode.workspace.getWorkspaceFolder(vscode.Uri.file(filePath));
+              if (!workspaceFolder) {
+                console.warn('[git-ai] AIEditManager: No workspace folder found for', filePath, '- skipping AI checkpoint');
+              } else {
               const chatSessionPath = path.join(storagePath, 'chatSessions', `${sessionId}.json`);
-              console.log('[git-ai] AIEditManager: AI edit detected for', filePath, '- triggering AI checkpoint (sessionId:', sessionId, ', requestId:', requestId, ', chatSessionPath:', chatSessionPath, ', workspaceFolder:', workspaceFolder.uri.fsPath, ')');
+              console.log('[git-ai] AIEditManager: AI edit detected for', filePath, '- triggering AI checkpoint (sessionId:', sessionId, ', chatSessionPath:', chatSessionPath, ', workspaceFolder:', workspaceFolder.uri.fsPath, ')');
 
               // Get dirty files and ensure the saved file is included with its content from VS Code
               const dirtyFiles = this.getDirtyFiles();
@@ -134,52 +180,104 @@ export class AIEditManager {
 
               console.log('[git-ai] AIEditManager: Dirty files with saved file content:', dirtyFiles);
               this.checkpoint("ai", JSON.stringify({
+                hook_event_name: "after_edit",
                 chatSessionPath,
                 sessionId,
-                requestId,
                 workspaceFolder: workspaceFolder.uri.fsPath,
                 dirtyFiles,
               }));
               checkpointTriggered = true;
+              }
             }
+          } catch (e) {
+            console.error('[git-ai] AIEditManager: Unable to trigger AI checkpoint for', filePath, e);
           }
-        } catch (e) {
-          console.error('[git-ai] AIEditManager: Unable to trigger AI checkpoint for', filePath, e);
         }
       }
     }
 
     if (!checkpointTriggered) {
-      console.log('[git-ai] AIEditManager: No AI pattern detected for', filePath, '- triggering human checkpoint');
-      this.checkpoint("human");
+      console.log('[git-ai] AIEditManager: No AI pattern detected for', filePath, '- skipping checkpoint');
     }
 
     // Cleanup
     this.pendingSaves.delete(filePath);
     this.snapshotOpenEvents.delete(filePath);
   }
 
-  public triggerInitialHumanCheckpoint(): void {
-    console.log('[git-ai] AIEditManager: Triggering initial human checkpoint');
-    this.checkpoint("human");
-  }
-
-  async checkpoint(author: "human" | "ai" | "ai_tab", hookInput?: string): Promise<boolean> {
-    if (!(await this.checkGitAi())) {
-      return false;
+  /**
+   * Trigger a human checkpoint with debouncing per file.
+   * Debounce logic: trigger immediately, but skip files that were already checkpointed within the debounce window.
+   */
+  private triggerHumanCheckpoint(willEditFilepaths: string[]): void {
+    if (!willEditFilepaths || willEditFilepaths.length === 0) {
+      console.warn('[git-ai] AIEditManager: Cannot trigger human checkpoint without files');
+      return;
     }
 
-    // Throttle human checkpoints
-    if (author === "human") {
-      const now = new Date();
-      if (this.lastHumanCheckpointAt && (now.getTime() - this.lastHumanCheckpointAt.getTime()) < this.HUMAN_CHECKPOINT_DEBOUNCE_MS) {
-        console.log('[git-ai] AIEditManager: Skipping human checkpoint due to debounce');
+    // Filter out files that were recently checkpointed (within debounce window)
+    const now = Date.now();
+    const filesToCheckpoint = willEditFilepaths.filter(filePath => {
+      const lastCheckpoint = this.lastHumanCheckpointAt.get(filePath);
+      if (lastCheckpoint && (now - lastCheckpoint) < this.HUMAN_CHECKPOINT_DEBOUNCE_MS) {
+        console.log('[git-ai] AIEditManager: Skipping file due to debounce:', filePath);
         return false;
       }
-      this.lastHumanCheckpointAt = now;
+      return true;
+    });
+
+    if (filesToCheckpoint.length === 0) {
+      console.log('[git-ai] AIEditManager: All files were recently checkpointed, skipping');
+      return;
+    }
+
+    // Update last checkpoint time for files we're about to checkpoint
+    filesToCheckpoint.forEach(filePath => {
+      this.lastHumanCheckpointAt.set(filePath, now);
+    });
+
+    // Get dirty files
+    const dirtyFiles = this.getDirtyFiles();
+
+    // Add the files we're checkpointing to dirtyFiles (even if they're not dirty)
+    // Read from VS Code to handle codespaces lag
+    filesToCheckpoint.forEach(filePath => {
+      const fileDoc = vscode.workspace.textDocuments.find(doc =>
+        doc.uri.fsPath === filePath && doc.uri.scheme === "file"
+      );
+      if (fileDoc) {
+        dirtyFiles[filePath] = fileDoc.getText();
+      }
+    });
+
+    // Find workspace folder
+    const workspaceFolder = vscode.workspace.getWorkspaceFolder(vscode.Uri.file(filesToCheckpoint[0]))
+      || vscode.workspace.workspaceFolders?.[0];
+
+    if (!workspaceFolder) {
+      console.warn('[git-ai] AIEditManager: No workspace folder found for human checkpoint');
+      return;
+    }
+
+    console.log('[git-ai] AIEditManager: Triggering human checkpoint for files:', filesToCheckpoint);
+
+    // Prepare hook input for human checkpoint (session ID is not reliable, so we skip it)
+    const hookInput = JSON.stringify({
+      hook_event_name: "before_edit",
+      workspaceFolder: workspaceFolder.uri.fsPath,
+      will_edit_filepaths: filesToCheckpoint,
+      dirtyFiles: dirtyFiles,
+    });
+
+    this.checkpoint("human", hookInput);
+  }
+
+  async checkpoint(author: "human" | "ai" | "ai_tab", hookInput: string): Promise<boolean> {
+    if (!(await this.checkGitAi())) {
+      return false;
     }
 
-    return new Promise<boolean>((resolve, reject) => {
+    return new Promise<boolean>((resolve) => {
       let workspaceRoot: string | undefined;
 
       const activeEditor = vscode.window.activeTextEditor;
@@ -202,12 +300,16 @@ export class AIEditManager {
       }
 
       const args = ["checkpoint"];
-      if (author === "ai") {
+      if (author === "ai_tab") {
+        args.push("ai_tab");
+      } else {
         args.push("github-copilot");
       }
-      if (hookInput) {
-        args.push("--hook-input", "stdin");
-      }
+      args.push("--hook-input", "stdin");
+
+      console.log('[git-ai] AIEditManager: Spawning git-ai with args:', args);
+      console.log('[git-ai] AIEditManager: Workspace root:', workspaceRoot);
+      console.log('[git-ai] AIEditManager: Hook input:', hookInput);
 
       const proc = spawn("git-ai", args, { cwd: workspaceRoot });
 
@@ -320,4 +422,4 @@ export class AIEditManager {
       });
     });
   }
-}
+}

agent-support/vscode/src/consts.ts

@@ -1,6 +1,6 @@
 import { IDEHostKind } from "./utils/host-kind";
 
-export const MIN_GIT_AI_VERSION = "1.0.3";
+export const MIN_GIT_AI_VERSION = "1.0.22";
 
 // Use GitHub URL to avoid VS Code open URL safety prompt
 export const GIT_AI_INSTALL_DOCS_URL = "https://github.com/acunniffe/git-ai?tab=readme-ov-file#quick-start";

agent-support/vscode/src/extension.ts

@@ -28,8 +28,6 @@ export function activate(context: vscode.ExtensionContext) {
 
   if (ideHostCfg.kind == IDEHostKindVSCode) {
     console.log('[git-ai] Using VS Code/Copilot detection strategy');
-    // Trigger initial human checkpoint
-    aiEditManager.triggerInitialHumanCheckpoint();
 
     // Save event
     context.subscriptions.push(
@@ -52,6 +50,15 @@ export function activate(context: vscode.ExtensionContext) {
       })
     );
   }
+
+  // vscode.commands.getCommands(true)
+  //   .then(commands => {
+  //     const content = commands.join('\n');
+  //     vscode.workspace.openTextDocument({ content, language: 'text' })
+  //       .then(doc => vscode.window.showTextDocument(doc));
+  //   });
 }
 
-export function deactivate() { }
+export function deactivate() {
+  console.log('[git-ai] extension deactivated');
+}