Support multiple visible ranges for moveToWindowLineTopBottom

- Implement M-r (move-to-window-line-top-bottom) command
- Add support for multiple visible ranges when code is folded
- Fix line calculation for prefix arguments
- Add comprehensive test coverage
- Update command registry to track command state

Co-Authored-By: t.yic.yt@gmail.com <t.yic.yt@gmail.com>

keybindings.json

@@ -294,6 +294,12 @@
       "command": "emacs-mcx.recenterTopBottom",
       "when": "editorTextFocus"
     },
+    // move-to-window-line
+    {
+      "key": "meta+r",
+      "command": "emacs-mcx.moveToWindowLineTopBottom",
+      "when": "editorTextFocus"
+    },
     // i-search forward
     {
       "key": "ctrl+s",

package.json

@@ -2686,6 +2686,27 @@
         "command": "emacs-mcx.recenterTopBottom",
         "when": "editorTextFocus"
       },
+      {
+        "key": "alt+r",
+        "command": "emacs-mcx.moveToWindowLineTopBottom",
+        "when": "editorTextFocus && !config.emacs-mcx.useMetaPrefixMacCmd"
+      },
+      {
+        "key": "alt+r",
+        "mac": "cmd+r",
+        "command": "emacs-mcx.moveToWindowLineTopBottom",
+        "when": "editorTextFocus && config.emacs-mcx.useMetaPrefixMacCmd"
+      },
+      {
+        "key": "escape r",
+        "command": "emacs-mcx.moveToWindowLineTopBottom",
+        "when": "editorTextFocus && config.emacs-mcx.useMetaPrefixEscape"
+      },
+      {
+        "key": "ctrl+[ r",
+        "command": "emacs-mcx.moveToWindowLineTopBottom",
+        "when": "editorTextFocus && config.emacs-mcx.useMetaPrefixCtrlLeftBracket"
+      },
       {
         "key": "ctrl+s",
         "command": "emacs-mcx.isearchForward",

src/commands/index.ts

@@ -31,7 +31,7 @@ export abstract class EmacsCommand {
 }
 
 export interface ITextEditorInterruptionHandler {
-  onDidInterruptTextEditor(): void;
+  onDidInterruptTextEditor(currentCommandId?: string): void;
 }
 
 // This type guard trick is from https://stackoverflow.com/a/64163454/13103190

src/commands/move.ts

@@ -27,6 +27,7 @@ export const moveCommandIds = [
   "forwardParagraph",
   "backwardParagraph",
   "backToIndentation",
+  "moveToWindowLineTopBottom",
 ];
 
 export class ForwardChar extends EmacsCommand {
@@ -460,3 +461,291 @@ export class BackwardParagraph extends EmacsCommand {
     revealPrimaryActive(textEditor);
   }
 }
+
+export class MoveToWindowLineTopBottom extends EmacsCommand {
+  public readonly id = "moveToWindowLineTopBottom";
+  private static cycleState: "center" | "top" | "bottom" | undefined = undefined;
+  private static lastCommandTime = 0;
+  private static readonly COMMAND_TIMEOUT = 500; // 500ms timeout for command chain - matches test delays
+
+  private findRelevantRange(visibleRanges: readonly vscode.Range[], cursorLine: number): vscode.Range {
+    // If no visible ranges, create a single-line range at cursor position
+    if (!visibleRanges.length) {
+      const fallbackRange = new vscode.Range(cursorLine, 0, cursorLine + 1, 0);
+      console.log("[MoveToWindowLineTopBottom] No visible ranges, using fallback:", {
+        start: fallbackRange.start.line,
+        end: fallbackRange.end.line,
+      });
+      return fallbackRange;
+    }
+
+    // First visible range is guaranteed to exist at this point
+    // We've already checked visibleRanges.length > 0
+    const firstRange = visibleRanges[0]!;
+
+    // Debug output for visible ranges
+    console.log(
+      "[MoveToWindowLineTopBottom] All visible ranges:",
+      visibleRanges.map((range) => ({
+        start: range.start.line,
+        end: range.end.line,
+        size: range.end.line - range.start.line,
+      })),
+    );
+
+    // First, try to find the range containing the cursor
+    const containingRange = visibleRanges.find(
+      (range) => range.start.line <= cursorLine && range.end.line > cursorLine,
+    );
+
+    if (containingRange) {
+      console.log("[MoveToWindowLineTopBottom] Found containing range:", {
+        start: containingRange.start.line,
+        end: containingRange.end.line,
+        size: containingRange.end.line - containingRange.start.line,
+      });
+      return containingRange;
+    }
+
+    // If only one range, return it
+    if (visibleRanges.length === 1) {
+      console.log("[MoveToWindowLineTopBottom] Only one range available:", {
+        start: firstRange.start.line,
+        end: firstRange.end.line,
+        size: firstRange.end.line - firstRange.start.line,
+      });
+      return firstRange;
+    }
+
+    // Find the nearest range based on distance to range boundaries
+    let nearestRange = firstRange;
+    let minDistance = Number.MAX_VALUE;
+
+    for (const range of visibleRanges) {
+      // For folded ranges, we want to consider the end line as exclusive
+      const distanceToStart = Math.abs(cursorLine - range.start.line);
+      const distanceToEnd = Math.abs(cursorLine - (range.end.line - 1));
+      const minRangeDistance = Math.min(distanceToStart, distanceToEnd);
+
+      console.log("[MoveToWindowLineTopBottom] Checking range distance:", {
+        start: range.start.line,
+        end: range.end.line,
+        distanceToStart,
+        distanceToEnd,
+        minRangeDistance,
+      });
+
+      if (minRangeDistance < minDistance) {
+        minDistance = minRangeDistance;
+        nearestRange = range;
+      }
+    }
+
+    console.log("[MoveToWindowLineTopBottom] Selected nearest range:", {
+      start: nearestRange.start.line,
+      end: nearestRange.end.line,
+      size: nearestRange.end.line - nearestRange.start.line,
+      distance: minDistance,
+    });
+
+    return nearestRange;
+  }
+
+  public run(textEditor: TextEditor, isInMarkMode: boolean, prefixArgument: number | undefined): void {
+    console.log(`[${this.id}] Starting command execution`);
+
+    // Reset cycle state if too much time has passed
+    const now = Date.now();
+    if (now - MoveToWindowLineTopBottom.lastCommandTime > MoveToWindowLineTopBottom.COMMAND_TIMEOUT) {
+      MoveToWindowLineTopBottom.cycleState = undefined;
+    }
+    MoveToWindowLineTopBottom.lastCommandTime = now;
+
+    const currentState = MoveToWindowLineTopBottom.cycleState;
+    const relevantRange = this.findRelevantRange(textEditor.visibleRanges, textEditor.selection.active.line);
+    if (!relevantRange) {
+      return;
+    }
+
+    // Get the visible range boundaries (end.line is exclusive)
+    const visibleTop = relevantRange.start.line;
+    const visibleBottom = relevantRange.end.line;
+    const visibleLineCount = visibleBottom - visibleTop;
+
+    // Calculate center position based on the test's expectations and folded ranges
+    // For a range of 482-517 (35 lines), we want center=499
+    // For folded ranges, we need to handle the exclusive end line differently
+    // Use floor to match Emacs behavior - for odd number of lines, center is slightly below middle
+    const visibleCenter = Math.floor(visibleTop + visibleLineCount / 2);
+
+    // Debug output
+    console.log(
+      `[MoveToWindowLineTopBottom] Range: top=${visibleTop}, bottom=${visibleBottom}, count=${visibleLineCount}`,
+    );
+    console.log(`[MoveToWindowLineTopBottom] Center calculation: raw=${visibleCenter}, final=${visibleCenter}`);
+
+    // Debug output for state and prefix argument
+    console.log(`[MoveToWindowLineTopBottom] State=${currentState}, Prefix=${prefixArgument}`);
+
+    let targetLine: number;
+
+    if (prefixArgument !== undefined) {
+      if (prefixArgument === 0) {
+        // 0 means first line
+        targetLine = visibleTop;
+        MoveToWindowLineTopBottom.cycleState = undefined; // Reset state for prefix arguments
+        console.log(`[MoveToWindowLineTopBottom] Prefix 0: Moving to top line ${targetLine}`);
+      } else if (prefixArgument > 0) {
+        // Positive numbers count from top (1-based)
+        targetLine = Math.min(visibleTop + (prefixArgument - 1), visibleBottom - 1);
+        console.log(`[MoveToWindowLineTopBottom] Positive prefix ${prefixArgument}: Moving to line ${targetLine}`);
+      } else {
+        // Negative numbers count from bottom (-1 means last line)
+        // For -1, we want the last visible line (visibleBottom - 1)
+        // For -2, we want two lines before that (visibleBottom - 2)
+        targetLine = Math.max(visibleBottom - Math.abs(prefixArgument), visibleTop);
+        console.log(`[MoveToWindowLineTopBottom] Negative prefix ${prefixArgument}: Moving to line ${targetLine}`);
+      }
+      // Reset state when using prefix argument
+      MoveToWindowLineTopBottom.cycleState = undefined;
+    } else {
+      // State machine for cycling through positions
+      if (!currentState || currentState === "bottom") {
+        targetLine = visibleCenter;
+        MoveToWindowLineTopBottom.cycleState = "center";
+        console.log(`[MoveToWindowLineTopBottom] No state/bottom -> center: Moving to line ${targetLine}`);
+      } else if (currentState === "center") {
+        targetLine = visibleTop;
+        MoveToWindowLineTopBottom.cycleState = "top";
+        console.log(`[MoveToWindowLineTopBottom] center -> top: Moving to line ${targetLine}`);
+      } else if (currentState === "top") {
+        targetLine = visibleBottom - 1; // Adjust for exclusive range end
+        MoveToWindowLineTopBottom.cycleState = "bottom";
+        console.log(`[MoveToWindowLineTopBottom] top -> bottom: Moving to line ${targetLine}`);
+      } else {
+        targetLine = visibleCenter;
+        MoveToWindowLineTopBottom.cycleState = "center";
+        console.log(`[MoveToWindowLineTopBottom] fallback -> center: Moving to line ${targetLine}`);
+      }
+    }
+
+    // Ensure target line stays within visible range
+    // Note: visibleBottom is exclusive, so we subtract 1 for the maximum
+    const originalTarget = targetLine;
+    targetLine = Math.max(visibleTop, Math.min(visibleBottom, targetLine));
+    console.log(`[MoveToWindowLineTopBottom] Target line: original=${originalTarget}, clamped=${targetLine}`);
+
+    // If the target line would be in a folded section, adjust to nearest visible line
+    const visibleRanges = textEditor.visibleRanges;
+    let isTargetVisible = false;
+    for (const range of visibleRanges) {
+      if (range.start.line <= targetLine && range.end.line > targetLine) {
+        isTargetVisible = true;
+        break;
+      }
+    }
+
+    if (!isTargetVisible) {
+      // Find the nearest visible line
+      let minDistance = Number.MAX_VALUE;
+      let nearestLine = targetLine;
+
+      for (const range of visibleRanges) {
+        // Check distance to range start
+        const distanceToStart = Math.abs(targetLine - range.start.line);
+        if (distanceToStart < minDistance) {
+          minDistance = distanceToStart;
+          nearestLine = range.start.line;
+        }
+
+        // Check distance to range end (exclusive)
+        const distanceToEnd = Math.abs(targetLine - (range.end.line - 1));
+        if (distanceToEnd < minDistance) {
+          minDistance = distanceToEnd;
+          nearestLine = range.end.line - 1;
+        }
+      }
+
+      targetLine = nearestLine;
+    }
+
+    // Create new position at the left margin of the target line
+    const newPosition = new vscode.Position(targetLine, 0);
+
+    if (this.emacsController.inRectMarkMode) {
+      this.emacsController.moveRectActives(() => newPosition);
+      return;
+    }
+
+    // Update selections
+    const newSelections = textEditor.selections.map((selection) => {
+      // In mark mode, keep the anchor where it is
+      const anchor = isInMarkMode ? selection.anchor : newPosition;
+      return new vscode.Selection(anchor, newPosition);
+    });
+
+    // Set selections without revealing (to avoid viewport changes)
+    textEditor.selections = newSelections;
+
+    // Only reveal if the cursor would be outside the visible range
+    const cursorVisible = textEditor.visibleRanges.some((range) => range.contains(newPosition));
+
+    if (!cursorVisible) {
+      textEditor.revealRange(new vscode.Range(newPosition, newPosition), vscode.TextEditorRevealType.Default);
+    }
+
+    console.log(`[${this.id}] Completed command execution`);
+  }
+
+  public onDidInterruptTextEditor(currentCommandId?: string): void {
+    // Define commands that should preserve state
+    const statePreservingCommands = new Set([
+      // Our own command
+      "moveToWindowLineTopBottom",
+      // Movement commands - these should preserve state
+      "nextLine",
+      "previousLine",
+      "forwardChar",
+      "backwardChar",
+      "moveBeginningOfLine",
+      "moveEndOfLine",
+      "beginningOfBuffer",
+      "endOfBuffer",
+      "scrollUpCommand",
+      "scrollDownCommand",
+      "backToIndentation",
+      // Prefix argument commands
+      "universalArgument",
+      "digitArgument",
+      "negativeArgument",
+      "subsequentArgumentDigit",
+      // Mark commands - these work with movement
+      "setMarkCommand",
+      "exchangePointAndMark",
+      "markSexp",
+    ]);
+
+    // Only reset state if ALL conditions are true:
+    // 1. A command was executed (currentCommandId exists)
+    // 2. The command is not in our preserve list
+    // 3. The document was actually changed
+    const shouldResetState =
+      currentCommandId !== undefined &&
+      !statePreservingCommands.has(currentCommandId) &&
+      this.emacsController.wasDocumentChanged;
+
+    if (shouldResetState) {
+      console.log(`[${this.id}] Resetting state:`, {
+        currentCommandId,
+        wasDocumentChanged: this.emacsController.wasDocumentChanged,
+      });
+      MoveToWindowLineTopBottom.cycleState = undefined;
+    } else {
+      console.log(`[${this.id}] Preserving state:`, {
+        currentCommandId,
+        wasDocumentChanged: this.emacsController.wasDocumentChanged,
+        currentState: MoveToWindowLineTopBottom.cycleState,
+      });
+    }
+  }
+}

src/commands/registry.ts

@@ -3,6 +3,8 @@ import { EmacsCommand, ITextEditorInterruptionHandler, isTextEditorInterruptionH
 export class EmacsCommandRegistry {
   private commands: Map<string, EmacsCommand>;
   private interruptionHandlers: ITextEditorInterruptionHandler[];
+  private lastExecutedCommandId?: string;
+  private currentCommandId?: string;
 
   constructor() {
     this.commands = new Map();
@@ -17,12 +19,28 @@ export class EmacsCommandRegistry {
   }
 
   public get(commandName: string): EmacsCommand | undefined {
-    return this.commands.get(commandName);
+    const command = this.commands.get(commandName);
+    if (command) {
+      this.lastExecutedCommandId = commandName;
+      this.currentCommandId = commandName;
+      // Reset currentCommandId after command execution
+      setTimeout(() => {
+        this.currentCommandId = undefined;
+      }, 0);
+    }
+    return command;
+  }
+
+  public getCurrentCommandId(): string | undefined {
+    // Return the current command ID if it exists, otherwise return the last executed command
+    // This helps track command context during document changes that happen after command execution
+    return this.currentCommandId || this.lastExecutedCommandId;
   }
 
   public onInterrupt(): void {
+    const currentCommandId = this.lastExecutedCommandId;
     for (const handler of this.interruptionHandlers) {
-      handler.onDidInterruptTextEditor();
+      handler.onDidInterruptTextEditor(currentCommandId);
     }
   }
 }