@fresh-editor/fresh-editor 0.1.67 → 0.1.70

package/plugins/vi_mode.ts

@@ -1,4 +1,6 @@
 /// <reference path="./lib/fresh.d.ts" />
+const editor = getEditor();
+
 
 /**
  * Vi Mode Plugin for Fresh Editor
@@ -13,10 +15,23 @@
  */
 
 // Vi mode state
-type ViMode = "normal" | "insert" | "operator-pending" | "find-char" | "visual" | "visual-line" | "text-object";
+type ViMode = "normal" | "insert" | "operator-pending" | "find-char" | "visual" | "visual-line" | "visual-block" | "text-object";
 type FindCharType = "f" | "t" | "F" | "T" | null;
 type TextObjectType = "inner" | "around" | null;
 
+// Types for tracking repeatable changes
+type ChangeType = "simple" | "operator-motion" | "operator-textobj" | "insert" | "line-op";
+
+interface LastChange {
+  type: ChangeType;
+  action?: string;           // For simple actions like "delete_forward", "delete_line"
+  operator?: string;         // For operator+motion/textobj: "d", "c", "y"
+  motion?: string;           // For operator+motion: the motion action
+  textObject?: { modifier: TextObjectType; object: string }; // For operator+textobj
+  count?: number;            // Count used with the command
+  insertedText?: string;     // Text inserted during insert mode
+}
+
 interface ViState {
   mode: ViMode;
   pendingOperator: string | null;
@@ -24,9 +39,11 @@ interface ViState {
   pendingTextObject: TextObjectType; // For i/a text objects
   lastFindChar: { type: FindCharType; char: string } | null; // For ; and , repeat
   count: number | null;
-  lastCommand: (() => void) | null; // For '.' repeat
+  lastChange: LastChange | null; // For '.' repeat
   lastYankWasLinewise: boolean; // Track if last yank was line-wise for proper paste
   visualAnchor: number | null; // Starting position for visual mode selection
+  insertStartPos: number | null; // Cursor position when entering insert mode
+  visualBlockAnchor: { line: number; col: number } | null; // For visual block mode
 }
 
 const state: ViState = {
@@ -36,9 +53,11 @@ const state: ViState = {
   pendingTextObject: null,
   lastFindChar: null,
   count: null,
-  lastCommand: null,
+  lastChange: null,
   lastYankWasLinewise: false,
   visualAnchor: null,
+  insertStartPos: null,
+  visualBlockAnchor: null,
 };
 
 // Mode indicator for status bar
@@ -46,17 +65,19 @@ function getModeIndicator(mode: ViMode): string {
   const countPrefix = state.count !== null ? `${state.count} ` : "";
   switch (mode) {
     case "normal":
-      return `-- NORMAL --${countPrefix ? ` (${state.count})` : ""}`;
+      return `-- ${editor.t("mode.normal")} --${countPrefix ? ` (${state.count})` : ""}`;
     case "insert":
-      return "-- INSERT --";
+      return `-- ${editor.t("mode.insert")} --`;
     case "operator-pending":
-      return `-- OPERATOR (${state.pendingOperator}) --${countPrefix ? ` (${state.count})` : ""}`;
+      return `-- ${editor.t("mode.operator")} (${state.pendingOperator}) --${countPrefix ? ` (${state.count})` : ""}`;
     case "find-char":
-      return `-- FIND (${state.pendingFindChar}) --`;
+      return `-- ${editor.t("mode.find")} (${state.pendingFindChar}) --`;
     case "visual":
-      return `-- VISUAL --${countPrefix ? ` (${state.count})` : ""}`;
+      return `-- ${editor.t("mode.visual")} --${countPrefix ? ` (${state.count})` : ""}`;
     case "visual-line":
-      return `-- VISUAL LINE --${countPrefix ? ` (${state.count})` : ""}`;
+      return `-- ${editor.t("mode.visual_line")} --${countPrefix ? ` (${state.count})` : ""}`;
+    case "visual-block":
+      return `-- ${editor.t("mode.visual_block")} --${countPrefix ? ` (${state.count})` : ""}`;
     case "text-object":
       return `-- ${state.pendingOperator}${state.pendingTextObject === "inner" ? "i" : "a"}? --`;
     default:
@@ -81,27 +102,69 @@ function switchMode(newMode: ViMode): void {
 
   // Preserve count when entering operator-pending or text-object mode (for 3dw = delete 3 words)
   // Also preserve count in visual modes
-  if (newMode !== "operator-pending" && newMode !== "text-object" && newMode !== "visual" && newMode !== "visual-line") {
+  if (newMode !== "operator-pending" && newMode !== "text-object" &&
+      newMode !== "visual" && newMode !== "visual-line" && newMode !== "visual-block") {
     state.count = null;
   }
 
   // Clear visual anchor when leaving visual modes
-  if (newMode !== "visual" && newMode !== "visual-line") {
+  if (newMode !== "visual" && newMode !== "visual-line" && newMode !== "visual-block") {
     state.visualAnchor = null;
+    state.visualBlockAnchor = null;
     // Clear any selection when leaving visual mode by moving cursor
     // (any non-select movement clears selection in Fresh)
-    if (oldMode === "visual" || oldMode === "visual-line") {
+    if (oldMode === "visual" || oldMode === "visual-line" || oldMode === "visual-block") {
       editor.executeAction("move_left");
       editor.executeAction("move_right");
     }
   }
 
+  // Track insert mode start position for '.' repeat
+  if (newMode === "insert" && oldMode !== "insert") {
+    state.insertStartPos = editor.getCursorPosition();
+  }
+
+  // Capture inserted text when leaving insert mode (for '.' repeat)
+  if (oldMode === "insert" && newMode !== "insert" && state.insertStartPos !== null) {
+    captureInsertedText();
+  }
+
   // All modes use vi-{mode} naming, including insert mode
   // vi-insert has read_only=false so normal typing works, but Escape is bound
   editor.setEditorMode(`vi-${newMode}`);
   editor.setStatus(getModeIndicator(newMode));
 }
 
+// Capture text inserted during insert mode for '.' repeat
+async function captureInsertedText(): Promise<void> {
+  if (state.insertStartPos === null) return;
+
+  const endPos = editor.getCursorPosition();
+  if (endPos === null || endPos <= state.insertStartPos) {
+    state.insertStartPos = null;
+    return;
+  }
+
+  const bufferId = editor.getActiveBufferId();
+  const text = await editor.getBufferText(bufferId, state.insertStartPos, endPos);
+
+  if (text && text.length > 0) {
+    // Only record if we have a pending insert change or if there was actual text inserted
+    if (state.lastChange?.type === "insert" || !state.lastChange) {
+      state.lastChange = {
+        type: "insert",
+        insertedText: text,
+      };
+    } else if (state.lastChange.type === "simple" || state.lastChange.type === "operator-motion" ||
+               state.lastChange.type === "operator-textobj" || state.lastChange.type === "line-op") {
+      // A change command (c, s, etc.) was used - append the inserted text
+      state.lastChange.insertedText = text;
+    }
+  }
+
+  state.insertStartPos = null;
+}
+
 // Get the current count (defaults to 1 if no count specified)
 // Does NOT clear the count - that's done in switchMode or explicitly
 function getCount(): number {
@@ -175,6 +238,11 @@ const atomicOperatorActions: OperatorMotionMap = {
 // Apply an operator using atomic actions if available, otherwise selection-based approach
 // The count parameter specifies how many times to apply the motion (e.g., d3w = delete 3 words)
 function applyOperatorWithMotion(operator: string, motionAction: string, count: number = 1): void {
+  // Record last change for '.' repeat (only for delete and change, not yank)
+  if (operator === "d" || operator === "c") {
+    state.lastChange = { type: "operator-motion", operator, motion: motionAction, count };
+  }
+
   // For "change" operator, use delete action and then enter insert mode
   const lookupOperator = operator === "c" ? "d" : operator;
 
@@ -379,6 +447,7 @@ globalThis.vi_yank_operator = function (): void {
 // Line operations (dd, cc, yy) - support count prefix (3dd = delete 3 lines)
 globalThis.vi_delete_line = function (): void {
   const count = consumeCount();
+  state.lastChange = { type: "line-op", action: "delete_line", count };
   if (count === 1) {
     editor.executeAction("delete_line");
   } else {
@@ -388,7 +457,8 @@ globalThis.vi_delete_line = function (): void {
 };
 
 globalThis.vi_change_line = function (): void {
-  consumeCount(); // TODO: support count for change line
+  const count = consumeCount();
+  state.lastChange = { type: "line-op", action: "change_line", count };
   editor.executeAction("move_line_start");
   const start = editor.getCursorPosition();
   editor.executeAction("move_line_end");
@@ -413,32 +483,43 @@ globalThis.vi_yank_line = function (): void {
   editor.executeAction("move_up");
   editor.executeAction("move_line_start");
   state.lastYankWasLinewise = true;
-  editor.setStatus(`Yanked ${count} line${count > 1 ? "s" : ""}`);
+  editor.setStatus(editor.t("status.yanked_lines", { count: String(count) }));
   switchMode("normal");
 };
 
 // Single character operations - support count prefix (3x = delete 3 chars)
 globalThis.vi_delete_char = function (): void {
-  executeWithCount("delete_forward");
+  const count = consumeCount();
+  state.lastChange = { type: "simple", action: "delete_forward", count };
+  executeWithCount("delete_forward", count);
 };
 
 globalThis.vi_delete_char_before = function (): void {
-  executeWithCount("delete_backward");
+  const count = consumeCount();
+  state.lastChange = { type: "simple", action: "delete_backward", count };
+  executeWithCount("delete_backward", count);
 };
 
 globalThis.vi_replace_char = function (): void {
   // TODO: implement character replacement (need to read next char)
-  editor.setStatus("Replace char not yet implemented");
+  editor.setStatus(editor.t("status.replace_not_implemented"));
 };
 
 // Substitute (delete char and enter insert mode)
 globalThis.vi_substitute = function (): void {
-  editor.executeAction("delete_forward");
+  const count = consumeCount();
+  state.lastChange = { type: "simple", action: "substitute", count };
+  if (count > 1) {
+    editor.executeActions([{ action: "delete_forward", count }]);
+  } else {
+    editor.executeAction("delete_forward");
+  }
   switchMode("insert");
 };
 
 // Delete to end of line
 globalThis.vi_delete_to_end = function (): void {
+  state.lastChange = { type: "operator-motion", operator: "d", motion: "move_line_end" };
   const start = editor.getCursorPosition();
   editor.executeAction("move_line_end");
   const end = editor.getCursorPosition();
@@ -449,6 +530,7 @@ globalThis.vi_delete_to_end = function (): void {
 
 // Change to end of line
 globalThis.vi_change_to_end = function (): void {
+  state.lastChange = { type: "operator-motion", operator: "c", motion: "move_line_end" };
   const start = editor.getCursorPosition();
   editor.executeAction("move_line_end");
   const end = editor.getCursorPosition();
@@ -498,6 +580,104 @@ globalThis.vi_redo = function (): void {
   editor.executeAction("redo");
 };
 
+// Repeat last change (. command)
+globalThis.vi_repeat = async function (): Promise<void> {
+  if (!state.lastChange) {
+    editor.setStatus(editor.t("status.no_change_to_repeat"));
+    return;
+  }
+
+  const change = state.lastChange;
+  const count = consumeCount() || change.count || 1;
+
+  switch (change.type) {
+    case "simple": {
+      // Simple actions like x, X, s
+      if (change.action === "substitute") {
+        // Substitute: delete chars and insert text
+        if (count > 1) {
+          editor.executeActions([{ action: "delete_forward", count }]);
+        } else {
+          editor.executeAction("delete_forward");
+        }
+        if (change.insertedText) {
+          editor.insertText(change.insertedText);
+        }
+      } else if (change.action) {
+        // Simple action like delete_forward, delete_backward
+        if (count > 1) {
+          editor.executeActions([{ action: change.action, count }]);
+        } else {
+          editor.executeAction(change.action);
+        }
+      }
+      break;
+    }
+
+    case "line-op": {
+      // Line operations like dd, cc
+      if (change.action === "delete_line") {
+        if (count > 1) {
+          editor.executeActions([{ action: "delete_line", count }]);
+        } else {
+          editor.executeAction("delete_line");
+        }
+      } else if (change.action === "change_line") {
+        // Change line: delete line content and insert text
+        editor.executeAction("move_line_start");
+        const start = editor.getCursorPosition();
+        editor.executeAction("move_line_end");
+        const end = editor.getCursorPosition();
+        if (start !== null && end !== null) {
+          editor.deleteRange(editor.getActiveBufferId(), start, end);
+        }
+        if (change.insertedText) {
+          editor.insertText(change.insertedText);
+        }
+      }
+      break;
+    }
+
+    case "operator-motion": {
+      // Operator + motion like dw, cw, d$
+      if (change.operator && change.motion) {
+        if (change.operator === "c") {
+          // For change: do the delete part, then insert the text
+          applyOperatorWithMotion("d", change.motion, count);
+          if (change.insertedText) {
+            editor.insertText(change.insertedText);
+          }
+        } else {
+          applyOperatorWithMotion(change.operator, change.motion, count);
+        }
+      }
+      break;
+    }
+
+    case "operator-textobj": {
+      // Operator + text object like diw, ci"
+      if (change.operator && change.textObject) {
+        // Set up the pending state and call applyTextObject
+        state.pendingOperator = change.operator === "c" ? "d" : change.operator;
+        state.pendingTextObject = change.textObject.modifier;
+        await applyTextObject(change.textObject.object);
+        if (change.operator === "c" && change.insertedText) {
+          editor.insertText(change.insertedText);
+        }
+      }
+      break;
+    }
+
+    case "insert": {
+      // Pure insert (i, a, o, O)
+      if (change.insertedText) {
+        editor.insertText(change.insertedText);
+      }
+      break;
+    }
+  }
+};
+
 // Join lines
 globalThis.vi_join = function (): void {
   editor.executeAction("move_line_end");
@@ -610,6 +790,95 @@ globalThis.vi_visual_toggle_line = function (): void {
   }
 };
 
+// Enter visual block mode (Ctrl-v)
+globalThis.vi_visual_block = function (): void {
+  // Store anchor position for block selection
+  state.visualAnchor = editor.getCursorPosition();
+
+  // Calculate line and column for block anchor
+  const cursorPos = editor.getCursorPosition();
+  if (cursorPos !== null) {
+    const line = editor.getCursorLine() ?? 1;
+    const lineStart = editor.getLineStartPosition(line);
+    const col = lineStart !== null ? cursorPos - lineStart : 0;
+    state.visualBlockAnchor = { line, col };
+  }
+
+  // Select current character to start
+  editor.executeAction("select_right");
+  switchMode("visual-block");
+};
+
+// Visual block mode motions - these extend the rectangular selection
+globalThis.vi_vblock_left = function (): void {
+  executeWithCount("select_left");
+};
+
+globalThis.vi_vblock_down = function (): void {
+  executeWithCount("select_down");
+};
+
+globalThis.vi_vblock_up = function (): void {
+  executeWithCount("select_up");
+};
+
+globalThis.vi_vblock_right = function (): void {
+  executeWithCount("select_right");
+};
+
+globalThis.vi_vblock_line_start = function (): void {
+  consumeCount();
+  editor.executeAction("select_line_start");
+};
+
+globalThis.vi_vblock_line_end = function (): void {
+  consumeCount();
+  editor.executeAction("select_line_end");
+};
+
+// Visual block delete - delete the selected block
+globalThis.vi_vblock_delete = function (): void {
+  editor.executeAction("cut");
+  state.lastYankWasLinewise = false;
+  switchMode("normal");
+};
+
+// Visual block change - delete and enter insert mode
+globalThis.vi_vblock_change = function (): void {
+  editor.executeAction("cut");
+  switchMode("insert");
+};
+
+// Visual block yank
+globalThis.vi_vblock_yank = function (): void {
+  editor.executeAction("copy");
+  state.lastYankWasLinewise = false;
+  // Move cursor to start of selection
+  editor.executeAction("move_left");
+  switchMode("normal");
+};
+
+// Exit visual block mode
+globalThis.vi_vblock_escape = function (): void {
+  switchMode("normal");
+};
+
+// Toggle from visual block to other visual modes
+globalThis.vi_vblock_toggle_char = function (): void {
+  // Switch to character visual mode
+  state.mode = "visual";
+  editor.setEditorMode("vi-visual");
+  editor.setStatus(getModeIndicator("visual"));
+};
+
+globalThis.vi_vblock_toggle_line = function (): void {
+  // Switch to line visual mode
+  editor.executeAction("select_line");
+  state.mode = "visual-line";
+  editor.setEditorMode("vi-visual-line");
+  editor.setStatus(getModeIndicator("visual-line"));
+};
+
 // Visual mode motions - these extend the selection
 globalThis.vi_vis_left = function (): void {
   executeWithCount("select_left");
@@ -727,12 +996,18 @@ globalThis.vi_text_object_around = function (): void {
 async function applyTextObject(objectType: string): Promise<void> {
   const operator = state.pendingOperator;
   const isInner = state.pendingTextObject === "inner";
+  const modifier = state.pendingTextObject;
 
   if (!operator) {
     switchMode("normal");
     return;
   }
 
+  // Record last change for '.' repeat (only for delete and change, not yank)
+  if ((operator === "d" || operator === "c") && modifier) {
+    state.lastChange = { type: "operator-textobj", operator, textObject: { modifier, object: objectType } };
+  }
+
   const bufferId = editor.getActiveBufferId();
   const cursorPos = editor.getCursorPosition();
   if (cursorPos === null) {
@@ -1269,12 +1544,19 @@ editor.defineMode("vi-normal", null, [
   ["u", "vi_undo"],
   ["C-r", "vi_redo"],
 
+  // Repeat last change
+  [".", "vi_repeat"],
+
   // Visual mode
   ["v", "vi_visual_char"],
   ["V", "vi_visual_line"],
+  ["C-v", "vi_visual_block"],
 
   // Other
   ["J", "vi_join"],
+
+  // Command mode
+  [":", "vi_command_mode"],
 ], true); // read_only = true to prevent character insertion
 
 // Define vi-insert mode - only Escape is special, other keys insert text
@@ -1519,83 +1801,918 @@ editor.defineMode("vi-visual-line", null, [
   ["V", "vi_vis_escape"], // V again exits visual-line mode
 ], true);
 
+// Define vi-visual-block mode (column/block selection)
+editor.defineMode("vi-visual-block", null, [
+  // Count prefix
+  ["1", "vi_digit_1"],
+  ["2", "vi_digit_2"],
+  ["3", "vi_digit_3"],
+  ["4", "vi_digit_4"],
+  ["5", "vi_digit_5"],
+  ["6", "vi_digit_6"],
+  ["7", "vi_digit_7"],
+  ["8", "vi_digit_8"],
+  ["9", "vi_digit_9"],
+  ["0", "vi_vblock_line_start"],
+
+  // Motions (extend block selection)
+  ["h", "vi_vblock_left"],
+  ["j", "vi_vblock_down"],
+  ["k", "vi_vblock_up"],
+  ["l", "vi_vblock_right"],
+  ["$", "vi_vblock_line_end"],
+  ["^", "vi_vblock_line_start"],
+
+  // Switch to other visual modes
+  ["v", "vi_vblock_toggle_char"],
+  ["V", "vi_vblock_toggle_line"],
+
+  // Operators
+  ["d", "vi_vblock_delete"],
+  ["x", "vi_vblock_delete"],
+  ["c", "vi_vblock_change"],
+  ["s", "vi_vblock_change"],
+  ["y", "vi_vblock_yank"],
+
+  // Exit
+  ["Escape", "vi_vblock_escape"],
+  ["C-v", "vi_vblock_escape"], // Ctrl-v again exits visual-block mode
+], true);
+
 // ============================================================================
 // Register Commands
 // ============================================================================
 
 // Navigation commands
 const navCommands = [
-  ["vi_left", "Move left"],
-  ["vi_down", "Move down"],
-  ["vi_up", "Move up"],
-  ["vi_right", "Move right"],
-  ["vi_word", "Move to next word"],
-  ["vi_word_back", "Move to previous word"],
-  ["vi_word_end", "Move to end of word"],
-  ["vi_line_start", "Move to line start"],
-  ["vi_line_end", "Move to line end"],
-  ["vi_doc_start", "Move to document start"],
-  ["vi_doc_end", "Move to document end"],
-  ["vi_page_down", "Page down"],
-  ["vi_page_up", "Page up"],
-  ["vi_half_page_down", "Half page down"],
-  ["vi_half_page_up", "Half page up"],
-  ["vi_center_cursor", "Center cursor on screen"],
-  ["vi_search_forward", "Search forward"],
-  ["vi_search_backward", "Search backward"],
-  ["vi_find_next", "Find next match"],
-  ["vi_find_prev", "Find previous match"],
-  ["vi_find_char_f", "Find char forward"],
-  ["vi_find_char_t", "Find till char forward"],
-  ["vi_find_char_F", "Find char backward"],
-  ["vi_find_char_T", "Find till char backward"],
-  ["vi_find_char_repeat", "Repeat last find char"],
-  ["vi_find_char_repeat_reverse", "Repeat last find char (reverse)"],
+  ["vi_left", "move_left"],
+  ["vi_down", "move_down"],
+  ["vi_up", "move_up"],
+  ["vi_right", "move_right"],
+  ["vi_word", "move_word"],
+  ["vi_word_back", "move_word_back"],
+  ["vi_word_end", "move_word_end"],
+  ["vi_line_start", "move_line_start"],
+  ["vi_line_end", "move_line_end"],
+  ["vi_doc_start", "move_doc_start"],
+  ["vi_doc_end", "move_doc_end"],
+  ["vi_page_down", "page_down"],
+  ["vi_page_up", "page_up"],
+  ["vi_half_page_down", "half_page_down"],
+  ["vi_half_page_up", "half_page_up"],
+  ["vi_center_cursor", "center_cursor"],
+  ["vi_search_forward", "search_forward"],
+  ["vi_search_backward", "search_backward"],
+  ["vi_find_next", "find_next"],
+  ["vi_find_prev", "find_prev"],
+  ["vi_find_char_f", "find_char_f"],
+  ["vi_find_char_t", "find_char_t"],
+  ["vi_find_char_F", "find_char_F"],
+  ["vi_find_char_T", "find_char_T"],
+  ["vi_find_char_repeat", "find_char_repeat"],
+  ["vi_find_char_repeat_reverse", "find_char_repeat_reverse"],
 ];
 
-for (const [name, desc] of navCommands) {
-  editor.registerCommand(name, `Vi: ${desc}`, name, "vi-normal");
+for (const [name, key] of navCommands) {
+  editor.registerCommand(`%cmd.${key}`, `%cmd.${key}`, name, "vi-normal");
 }
 
 // Mode commands
 const modeCommands = [
-  ["vi_insert_before", "Insert before cursor"],
-  ["vi_insert_after", "Insert after cursor"],
-  ["vi_insert_line_start", "Insert at line start"],
-  ["vi_insert_line_end", "Insert at line end"],
-  ["vi_open_below", "Open line below"],
-  ["vi_open_above", "Open line above"],
-  ["vi_escape", "Return to normal mode"],
+  ["vi_insert_before", "insert_before"],
+  ["vi_insert_after", "insert_after"],
+  ["vi_insert_line_start", "insert_line_start"],
+  ["vi_insert_line_end", "insert_line_end"],
+  ["vi_open_below", "open_below"],
+  ["vi_open_above", "open_above"],
+  ["vi_escape", "return_to_normal"],
 ];
 
-for (const [name, desc] of modeCommands) {
-  editor.registerCommand(name, `Vi: ${desc}`, name, "vi-normal");
+for (const [name, key] of modeCommands) {
+  editor.registerCommand(`%cmd.${key}`, `%cmd.${key}`, name, "vi-normal");
 }
 
 // Operator commands
 const opCommands = [
-  ["vi_delete_operator", "Delete operator"],
-  ["vi_change_operator", "Change operator"],
-  ["vi_yank_operator", "Yank operator"],
-  ["vi_delete_line", "Delete line"],
-  ["vi_change_line", "Change line"],
-  ["vi_yank_line", "Yank line"],
-  ["vi_delete_char", "Delete character"],
-  ["vi_delete_char_before", "Delete char before cursor"],
-  ["vi_substitute", "Substitute character"],
-  ["vi_delete_to_end", "Delete to end of line"],
-  ["vi_change_to_end", "Change to end of line"],
-  ["vi_paste_after", "Paste after"],
-  ["vi_paste_before", "Paste before"],
-  ["vi_undo", "Undo"],
-  ["vi_redo", "Redo"],
-  ["vi_join", "Join lines"],
+  ["vi_delete_operator", "delete_operator"],
+  ["vi_change_operator", "change_operator"],
+  ["vi_yank_operator", "yank_operator"],
+  ["vi_delete_line", "delete_line"],
+  ["vi_change_line", "change_line"],
+  ["vi_yank_line", "yank_line"],
+  ["vi_delete_char", "delete_char"],
+  ["vi_delete_char_before", "delete_char_before"],
+  ["vi_substitute", "substitute"],
+  ["vi_delete_to_end", "delete_to_end"],
+  ["vi_change_to_end", "change_to_end"],
+  ["vi_paste_after", "paste_after"],
+  ["vi_paste_before", "paste_before"],
+  ["vi_undo", "undo"],
+  ["vi_redo", "redo"],
+  ["vi_join", "join_lines"],
 ];
 
-for (const [name, desc] of opCommands) {
-  editor.registerCommand(name, `Vi: ${desc}`, name, "vi-normal");
+for (const [name, key] of opCommands) {
+  editor.registerCommand(`%cmd.${key}`, `%cmd.${key}`, name, "vi-normal");
 }
 
+// ============================================================================
+// Colon Command Mode (:w, :q, :wq, :q!, :e, etc.)
+// ============================================================================
+
+// Start command mode - shows ":" prompt at the bottom
+globalThis.vi_command_mode = function (): void {
+  editor.startPrompt(":", "vi-command");
+};
+
+// Handle command execution when user presses Enter
+globalThis.vi_command_handler = async function (args: { prompt_type: string; input: string }): Promise<boolean> {
+  if (args.prompt_type !== "vi-command") {
+    return false; // Not our prompt, let other handlers process it
+  }
+
+  const input = args.input.trim();
+  if (!input) {
+    return true; // Empty command, just dismiss
+  }
+
+  // Parse the command
+  const result = await executeViCommand(input);
+
+  if (result.error) {
+    editor.setStatus(`E: ${result.error}`);
+  } else if (result.message) {
+    editor.setStatus(result.message);
+  }
+
+  return true; // We handled it
+};
+
+interface CommandResult {
+  error?: string;
+  message?: string;
+}
+
+// Command definition for the command table
+interface CommandDef {
+  name: string;           // Full command name
+  minAbbrev: number;      // Minimum abbreviation length (e.g., 1 for "w" -> "write")
+  allowBang: boolean;     // Whether command accepts ! suffix
+  hasArgs: boolean;       // Whether command accepts arguments
+}
+
+// Command table - defines all supported commands with their abbreviations
+// Vim allows any unambiguous prefix of a command name
+const commandTable: CommandDef[] = [
+  // File operations
+  { name: "write", minAbbrev: 1, allowBang: true, hasArgs: true },     // :w, :wri, :write
+  { name: "quit", minAbbrev: 1, allowBang: true, hasArgs: false },     // :q, :qu, :quit
+  { name: "wq", minAbbrev: 2, allowBang: true, hasArgs: false },       // :wq
+  { name: "wall", minAbbrev: 2, allowBang: false, hasArgs: false },    // :wa, :wall
+  { name: "qall", minAbbrev: 2, allowBang: true, hasArgs: false },     // :qa, :qall
+  { name: "wqall", minAbbrev: 3, allowBang: false, hasArgs: false },   // :wqa, :wqall
+  { name: "xit", minAbbrev: 1, allowBang: false, hasArgs: false },     // :x, :xit (same as :wq)
+  { name: "exit", minAbbrev: 3, allowBang: false, hasArgs: false },    // :exi, :exit
+  { name: "edit", minAbbrev: 1, allowBang: true, hasArgs: true },      // :e, :ed, :edit
+  { name: "enew", minAbbrev: 3, allowBang: true, hasArgs: false },     // :ene, :enew
+  { name: "saveas", minAbbrev: 3, allowBang: false, hasArgs: true },   // :sav, :saveas
+
+  // Buffer navigation
+  { name: "next", minAbbrev: 1, allowBang: true, hasArgs: false },     // :n, :next
+  { name: "previous", minAbbrev: 4, allowBang: true, hasArgs: false }, // :prev, :previous
+  { name: "bnext", minAbbrev: 2, allowBang: false, hasArgs: false },   // :bn, :bnext
+  { name: "bprevious", minAbbrev: 2, allowBang: false, hasArgs: false },// :bp, :bprev, :bprevious
+  { name: "bdelete", minAbbrev: 2, allowBang: true, hasArgs: false },  // :bd, :bdelete
+  { name: "buffer", minAbbrev: 1, allowBang: false, hasArgs: true },   // :b, :buffer
+  { name: "buffers", minAbbrev: 2, allowBang: false, hasArgs: false }, // :bu, :buffers (same as :ls)
+  { name: "ls", minAbbrev: 2, allowBang: false, hasArgs: false },      // :ls
+  { name: "files", minAbbrev: 3, allowBang: false, hasArgs: false },   // :fil, :files
+
+  // Splits
+  { name: "split", minAbbrev: 2, allowBang: false, hasArgs: true },    // :sp, :split
+  { name: "vsplit", minAbbrev: 2, allowBang: false, hasArgs: true },   // :vs, :vsplit
+  { name: "new", minAbbrev: 3, allowBang: false, hasArgs: true },      // :new
+  { name: "vnew", minAbbrev: 3, allowBang: false, hasArgs: true },     // :vne, :vnew
+  { name: "only", minAbbrev: 2, allowBang: true, hasArgs: false },     // :on, :only
+  { name: "close", minAbbrev: 3, allowBang: true, hasArgs: false },    // :clo, :close
+
+  // Tabs (mapped to buffers in Fresh)
+  { name: "tabnew", minAbbrev: 4, allowBang: false, hasArgs: true },   // :tabn, :tabnew
+  { name: "tabedit", minAbbrev: 4, allowBang: false, hasArgs: true },  // :tabe, :tabedit
+  { name: "tabclose", minAbbrev: 4, allowBang: true, hasArgs: false }, // :tabc, :tabclose
+  { name: "tabnext", minAbbrev: 5, allowBang: false, hasArgs: false }, // :tabne, :tabnext (note: different from :tabn)
+  { name: "tabprevious", minAbbrev: 4, allowBang: false, hasArgs: false }, // :tabp, :tabprevious
+
+  // Quickfix (mapped to diagnostics in Fresh)
+  { name: "copen", minAbbrev: 3, allowBang: false, hasArgs: false },   // :cop, :copen
+  { name: "cclose", minAbbrev: 3, allowBang: false, hasArgs: false },  // :ccl, :cclose
+  { name: "cnext", minAbbrev: 2, allowBang: true, hasArgs: false },    // :cn, :cnext
+  { name: "cprevious", minAbbrev: 2, allowBang: true, hasArgs: false },// :cp, :cprev, :cprevious
+  { name: "cfirst", minAbbrev: 3, allowBang: true, hasArgs: false },   // :cfir, :cfirst
+  { name: "clast", minAbbrev: 3, allowBang: true, hasArgs: false },    // :cla, :clast
+
+  // Search and replace
+  { name: "nohlsearch", minAbbrev: 3, allowBang: false, hasArgs: false }, // :noh, :nohlsearch
+  { name: "substitute", minAbbrev: 1, allowBang: false, hasArgs: true },  // :s, :substitute
+  { name: "global", minAbbrev: 1, allowBang: false, hasArgs: true },      // :g, :global
+  { name: "vglobal", minAbbrev: 2, allowBang: false, hasArgs: true },     // :vg, :vglobal
+
+  // Undo/redo
+  { name: "undo", minAbbrev: 1, allowBang: true, hasArgs: false },     // :u, :undo
+  { name: "redo", minAbbrev: 3, allowBang: false, hasArgs: false },    // :red, :redo
+
+  // Settings
+  { name: "set", minAbbrev: 2, allowBang: false, hasArgs: true },      // :se, :set
+
+  // Info commands
+  { name: "pwd", minAbbrev: 2, allowBang: false, hasArgs: false },     // :pw, :pwd
+  { name: "cd", minAbbrev: 2, allowBang: false, hasArgs: true },       // :cd
+  { name: "file", minAbbrev: 1, allowBang: false, hasArgs: true },     // :f, :file
+  { name: "help", minAbbrev: 1, allowBang: false, hasArgs: true },     // :h, :help
+  { name: "version", minAbbrev: 3, allowBang: false, hasArgs: false }, // :ver, :version
+
+  // Other
+  { name: "marks", minAbbrev: 4, allowBang: false, hasArgs: false },   // :mark, :marks
+  { name: "registers", minAbbrev: 3, allowBang: false, hasArgs: false },// :reg, :registers
+  { name: "jumps", minAbbrev: 2, allowBang: false, hasArgs: false },   // :ju, :jumps
+  { name: "syntax", minAbbrev: 2, allowBang: false, hasArgs: true },   // :sy, :syntax
+  { name: "read", minAbbrev: 1, allowBang: false, hasArgs: true },     // :r, :read
+  { name: "grep", minAbbrev: 2, allowBang: false, hasArgs: true },     // :gr, :grep
+  { name: "vimgrep", minAbbrev: 3, allowBang: false, hasArgs: true },  // :vim, :vimgrep
+  { name: "make", minAbbrev: 3, allowBang: true, hasArgs: true },      // :mak, :make
+  { name: "ascii", minAbbrev: 2, allowBang: false, hasArgs: false },   // :as, :ascii
+  { name: "revert", minAbbrev: 3, allowBang: false, hasArgs: false },  // :rev, :revert (Fresh-specific)
+];
+
+// Find a command by name or abbreviation
+function findCommand(input: string): CommandDef | null {
+  // Exact match first
+  for (const cmd of commandTable) {
+    if (cmd.name === input) {
+      return cmd;
+    }
+  }
+
+  // Then try abbreviation matching
+  const matches: CommandDef[] = [];
+  for (const cmd of commandTable) {
+    // Input must be at least minAbbrev chars and be a prefix of the command name
+    if (input.length >= cmd.minAbbrev && cmd.name.startsWith(input)) {
+      matches.push(cmd);
+    }
+  }
+
+  // Return only if unambiguous
+  if (matches.length === 1) {
+    return matches[0];
+  }
+
+  // Handle special short aliases that vim supports even if ambiguous
+  // These are the classic vim abbreviations that always work
+  const shortAliases: Record<string, string> = {
+    "w": "write",
+    "q": "quit",
+    "e": "edit",
+    "n": "next",
+    "N": "previous",
+    "b": "buffer",
+    "f": "file",
+    "h": "help",
+    "u": "undo",
+    "r": "read",
+    "s": "substitute",
+    "g": "global",
+    "x": "xit",
+  };
+
+  if (shortAliases[input]) {
+    return commandTable.find(c => c.name === shortAliases[input]) || null;
+  }
+
+  return null;
+}
+
+// Execute a vi command and return result
+async function executeViCommand(cmd: string): Promise<CommandResult> {
+  // Handle pure line numbers first (e.g., :42)
+  const lineNumMatch = cmd.match(/^(\d+)$/);
+  if (lineNumMatch) {
+    const lineNum = parseInt(lineNumMatch[1], 10);
+    return gotoLine(lineNum);
+  }
+
+  // Handle range prefix with command (e.g., :1,10d or :%d)
+  // Supported range formats: %, ., $, 'a, line numbers, and combinations with ,
+  let processedCmd = cmd;
+  let range: string | null = null;
+
+  const rangePattern = /^([%.$]|\d+|'[a-z])?(?:,([%.$]|\d+|'[a-z]))?\s*(.*)$/;
+  const rangeMatch = cmd.match(rangePattern);
+  if (rangeMatch && rangeMatch[3]) {
+    // There's a command after the range
+    range = (rangeMatch[1] || "") + (rangeMatch[2] ? "," + rangeMatch[2] : "");
+    processedCmd = rangeMatch[3];
+  }
+
+  // Handle special commands that start with symbols
+  if (processedCmd.startsWith("!")) {
+    // Shell command - not implemented
+    return { error: editor.t("error.shell_not_supported") };
+  }
+
+  // Handle +cmd syntax for :e +10 file (open file at line 10)
+  let plusCmd: string | null = null;
+  if (processedCmd.startsWith("+")) {
+    const plusMatch = processedCmd.match(/^\+(\S*)\s*(.*)/);
+    if (plusMatch) {
+      plusCmd = plusMatch[1] || "$"; // + alone means go to end
+      processedCmd = plusMatch[2];
+    }
+  }
+
+  // Split command into command name and arguments
+  // Supports: cmd, cmd!, cmd args, cmd! args
+  const match = processedCmd.match(/^([a-zA-Z]\w*)(!)?(?:\s+(.*))?$/);
+  if (!match) {
+    // Maybe it's just a command name without arguments
+    if (processedCmd.match(/^[a-zA-Z]+$/)) {
+      const cmdDef = findCommand(processedCmd);
+      if (cmdDef) {
+        return executeCommand(cmdDef.name, false, null, range);
+      }
+    }
+    return { error: editor.t("error.not_valid_command", { cmd: processedCmd }) };
+  }
+
+  const [, commandInput, bang, args] = match;
+  const force = bang === "!";
+
+  // Look up the command
+  const cmdDef = findCommand(commandInput);
+  if (!cmdDef) {
+    return { error: editor.t("error.unknown_command", { cmd: commandInput }) };
+  }
+
+  // Validate bang usage
+  if (force && !cmdDef.allowBang) {
+    return { error: editor.t("error.command_no_bang", { cmd: cmdDef.name }) };
+  }
+
+  // Execute the command
+  return executeCommand(cmdDef.name, force, args || null, range);
+}
+
+// Execute a resolved command
+async function executeCommand(
+  command: string,
+  force: boolean,
+  args: string | null,
+  _range: string | null  // Range support is limited for now
+): Promise<CommandResult> {
+
+  switch (command) {
+    case "write": {
+      // :w - save current file
+      // :w filename - save as filename (not implemented yet)
+      if (args) {
+        return { error: editor.t("error.save_as_not_implemented") };
+      }
+      editor.executeAction("save");
+      return { message: editor.t("status.file_saved") };
+    }
+
+    case "quit": {
+      // :q - quit (close buffer)
+      // :q! - force quit (discard changes)
+      const bufferId = editor.getActiveBufferId();
+      if (!force && editor.isBufferModified(bufferId)) {
+        return { error: editor.t("error.no_write_since_change", { cmd: ":q!" }) };
+      }
+      editor.executeAction("close_buffer");
+      return {};
+    }
+
+    case "wq":
+    case "xit":
+    case "exit": {
+      // :wq or :x - save and quit
+      editor.executeAction("save");
+      editor.executeAction("close_buffer");
+      return {};
+    }
+
+    case "wall": {
+      // :wa - save all buffers
+      editor.executeAction("save_all");
+      return { message: editor.t("status.all_files_saved") };
+    }
+
+    case "qall": {
+      // :qa - quit all
+      // :qa! - force quit all
+      if (force) {
+        editor.executeAction("quit_all");
+      } else {
+        // Check if any buffer is modified
+        const buffers = editor.listBuffers();
+        for (const buf of buffers) {
+          if (buf.modified) {
+            return { error: editor.t("error.no_write_since_change", { cmd: ":qa!" }) };
+          }
+        }
+        editor.executeAction("quit_all");
+      }
+      return {};
+    }
+
+    case "wqall": {
+      // :wqa or :xa - save all and quit
+      editor.executeAction("save_all");
+      editor.executeAction("quit_all");
+      return {};
+    }
+
+    case "edit": {
+      // :e - reload current file
+      // :e filename - open file
+      // :e! - force reload (discard changes)
+      if (!args) {
+        if (force) {
+          editor.executeAction("revert");
+          return { message: editor.t("status.file_reverted_discarded") };
+        }
+        const bufferId = editor.getActiveBufferId();
+        if (editor.isBufferModified(bufferId)) {
+          return { error: editor.t("error.no_write_since_change", { cmd: ":e!" }) };
+        }
+        editor.executeAction("revert");
+        return { message: editor.t("status.file_reverted") };
+      }
+      // Open the specified file
+      const path = args.trim();
+      editor.openFile(path, 0, 0);
+      return {};
+    }
+
+    case "enew": {
+      // :enew - create new buffer in current split
+      if (!force) {
+        const bufferId = editor.getActiveBufferId();
+        if (editor.isBufferModified(bufferId)) {
+          return { error: editor.t("error.no_write_since_change", { cmd: ":enew!" }) };
+        }
+      }
+      editor.executeAction("new_buffer");
+      return {};
+    }
+
+    case "revert": {
+      // :revert - Fresh-specific command to reload file
+      editor.executeAction("revert");
+      return { message: editor.t("status.file_reverted") };
+    }
+
+    case "next": {
+      // :n - next buffer
+      editor.executeAction("next_buffer");
+      return {};
+    }
+
+    case "previous": {
+      // :prev - previous buffer
+      editor.executeAction("prev_buffer");
+      return {};
+    }
+
+    case "bnext": {
+      // :bn - next buffer
+      editor.executeAction("next_buffer");
+      return {};
+    }
+
+    case "bprevious": {
+      // :bp - previous buffer
+      editor.executeAction("prev_buffer");
+      return {};
+    }
+
+    case "bdelete": {
+      // :bd - delete buffer (close)
+      // :bd! - force close even if modified
+      const bufferId = editor.getActiveBufferId();
+      if (!force && editor.isBufferModified(bufferId)) {
+        return { error: editor.t("error.no_write_since_change", { cmd: ":bd!" }) };
+      }
+      editor.executeAction("close_buffer");
+      return {};
+    }
+
+    case "buffer": {
+      // :b [N] - go to buffer N
+      // :b name - go to buffer matching name
+      if (!args) {
+        // Show current buffer info
+        const bufferId = editor.getActiveBufferId();
+        const info = editor.getBufferInfo(bufferId);
+        if (info) {
+          const name = info.path ? editor.pathBasename(info.path) : editor.t("info.no_name");
+          return { message: editor.t("info.buffer", { id: String(info.id), name }) };
+        }
+        return {};
+      }
+      // Try to parse as buffer number
+      const bufNum = parseInt(args.trim(), 10);
+      if (!isNaN(bufNum)) {
+        const buffers = editor.listBuffers();
+        const target = buffers.find(b => b.id === bufNum);
+        if (target) {
+          editor.showBuffer(target.id);
+          return {};
+        }
+        return { error: editor.t("error.buffer_not_found", { id: String(bufNum) }) };
+      }
+      // Try to match buffer by name
+      const buffers = editor.listBuffers();
+      const pattern = args.trim().toLowerCase();
+      const matches = buffers.filter(b => {
+        const name = b.path ? editor.pathBasename(b.path).toLowerCase() : "";
+        return name.includes(pattern);
+      });
+      if (matches.length === 1) {
+        editor.showBuffer(matches[0].id);
+        return {};
+      } else if (matches.length > 1) {
+        return { error: editor.t("error.multiple_buffers_match", { pattern: args }) };
+      }
+      return { error: editor.t("error.no_buffer_matching", { pattern: args }) };
+    }
+
+    case "buffers":
+    case "ls":
+    case "files": {
+      // :ls - list buffers
+      const buffers = editor.listBuffers();
+      const lines = buffers.map(buf => {
+        const modified = buf.modified ? " [+]" : "";
+        const current = buf.id === editor.getActiveBufferId() ? "%" : " ";
+        const name = buf.path ? editor.pathBasename(buf.path) : editor.t("info.no_name");
+        return `${current}${buf.id}: ${name}${modified}`;
+      });
+      return { message: lines.join(" | ") || editor.t("info.no_buffers") };
+    }
+
+    case "split": {
+      // :sp - horizontal split
+      editor.executeAction("split_horizontal");
+      if (args) {
+        // Open file in new split
+        const path = args.trim();
+        editor.openFile(path, 0, 0);
+      }
+      return {};
+    }
+
+    case "vsplit": {
+      // :vs - vertical split
+      editor.executeAction("split_vertical");
+      if (args) {
+        // Open file in new split
+        const path = args.trim();
+        editor.openFile(path, 0, 0);
+      }
+      return {};
+    }
+
+    case "new": {
+      // :new - create new buffer in horizontal split
+      editor.executeAction("split_horizontal");
+      editor.executeAction("new_buffer");
+      if (args) {
+        const path = args.trim();
+        editor.openFile(path, 0, 0);
+      }
+      return {};
+    }
+
+    case "vnew": {
+      // :vnew - create new buffer in vertical split
+      editor.executeAction("split_vertical");
+      editor.executeAction("new_buffer");
+      if (args) {
+        const path = args.trim();
+        editor.openFile(path, 0, 0);
+      }
+      return {};
+    }
+
+    case "only": {
+      // :only - close all other splits
+      editor.executeAction("close_other_splits");
+      return {};
+    }
+
+    case "close": {
+      // :close - close current split (same as :q for Fresh)
+      const bufferId = editor.getActiveBufferId();
+      if (!force && editor.isBufferModified(bufferId)) {
+        return { error: editor.t("error.no_write_since_change", { cmd: ":close!" }) };
+      }
+      editor.executeAction("close_buffer");
+      return {};
+    }
+
+    case "tabnew":
+    case "tabedit": {
+      // :tabnew - new tab (creates new buffer in Fresh)
+      editor.executeAction("new_buffer");
+      if (args) {
+        const path = args.trim();
+        editor.openFile(path, 0, 0);
+      }
+      return {};
+    }
+
+    case "tabclose": {
+      // :tabclose - close current tab/buffer
+      const bufferId = editor.getActiveBufferId();
+      if (!force && editor.isBufferModified(bufferId)) {
+        return { error: editor.t("error.no_write_since_change", { cmd: ":tabclose!" }) };
+      }
+      editor.executeAction("close_buffer");
+      return {};
+    }
+
+    case "tabnext": {
+      // :tabnext - next tab/buffer
+      editor.executeAction("next_buffer");
+      return {};
+    }
+
+    case "tabprevious": {
+      // :tabprev - previous tab/buffer
+      editor.executeAction("prev_buffer");
+      return {};
+    }
+
+    case "copen": {
+      // :copen - open diagnostics panel (Fresh equivalent)
+      editor.executeAction("show_diagnostics");
+      return {};
+    }
+
+    case "cclose": {
+      // :cclose - close diagnostics panel
+      return { message: editor.t("info.close_diagnostics") };
+    }
+
+    case "cnext": {
+      // :cnext - next diagnostic
+      editor.executeAction("goto_next_diagnostic");
+      return {};
+    }
+
+    case "cprevious": {
+      // :cprev - previous diagnostic
+      editor.executeAction("goto_prev_diagnostic");
+      return {};
+    }
+
+    case "cfirst": {
+      // :cfirst - first diagnostic
+      editor.executeAction("goto_first_diagnostic");
+      return {};
+    }
+
+    case "clast": {
+      // :clast - last diagnostic
+      editor.executeAction("goto_last_diagnostic");
+      return {};
+    }
+
+    case "nohlsearch": {
+      // :noh - clear search highlighting
+      editor.executeAction("clear_search");
+      return {};
+    }
+
+    case "substitute": {
+      // :s - substitute (not implemented)
+      // This would require parsing /pattern/replacement/flags
+      return { error: editor.t("error.substitute_not_implemented") };
+    }
+
+    case "global":
+    case "vglobal": {
+      // :g - global command (not implemented)
+      return { error: editor.t("error.global_not_implemented") };
+    }
+
+    case "undo": {
+      // :undo - undo
+      editor.executeAction("undo");
+      return {};
+    }
+
+    case "redo": {
+      // :redo - redo
+      editor.executeAction("redo");
+      return {};
+    }
+
+    case "set": {
+      // :set - set options (limited implementation)
+      if (!args) {
+        return { error: editor.t("error.set_usage") };
+      }
+      return handleSetCommand(args);
+    }
+
+    case "pwd": {
+      // :pwd - print working directory
+      const cwd = editor.getCwd();
+      return { message: cwd };
+    }
+
+    case "cd": {
+      // :cd - change directory (info only, can't actually change)
+      if (!args) {
+        return { message: editor.getCwd() };
+      }
+      return { error: editor.t("error.cannot_change_directory") };
+    }
+
+    case "file": {
+      // :f - show current file info
+      // :f name - rename current buffer (not implemented)
+      if (args) {
+        return { error: editor.t("error.rename_not_implemented") };
+      }
+      const bufferId = editor.getActiveBufferId();
+      const info = editor.getBufferInfo(bufferId);
+      if (info) {
+        const modified = info.modified ? editor.t("info.modified") : "";
+        const path = info.path || editor.t("info.no_name");
+        const line = editor.getCursorLine();
+        return { message: editor.t("info.file", { path, modified, line: String(line), bytes: String(info.length) }) };
+      }
+      return { error: editor.t("error.no_buffer") };
+    }
+
+    case "help": {
+      // :help - show help
+      if (args) {
+        return { message: editor.t("info.help_not_available", { topic: args }) };
+      }
+      return {
+        message: editor.t("info.help_commands")
+      };
+    }
+
+    case "version": {
+      // :version - show version
+      return { message: editor.t("info.version") };
+    }
+
+    case "marks": {
+      // :marks - show marks (not implemented)
+      return { error: editor.t("error.marks_not_implemented") };
+    }
+
+    case "registers": {
+      // :registers - show registers (not implemented)
+      return { error: editor.t("error.registers_not_implemented") };
+    }
+
+    case "jumps": {
+      // :jumps - show jump list (not implemented)
+      return { error: editor.t("error.jump_list_not_implemented") };
+    }
+
+    case "syntax": {
+      // :syntax - syntax info
+      if (args === "off") {
+        return { error: editor.t("error.syntax_cannot_disable") };
+      }
+      return { message: editor.t("status.syntax_always_on") };
+    }
+
+    case "read": {
+      // :r - read file into buffer (not implemented)
+      return { error: editor.t("error.read_not_implemented") };
+    }
+
+    case "saveas": {
+      // :saveas - save as (not implemented)
+      return { error: editor.t("error.saveas_not_implemented") };
+    }
+
+    case "grep":
+    case "vimgrep": {
+      // :grep - search (use Fresh's grep)
+      if (args) {
+        // Could potentially pass args to search, but for now just open search
+        editor.executeAction("search");
+        return { message: editor.t("info.use_search_dialog", { pattern: args }) };
+      }
+      editor.executeAction("search");
+      return {};
+    }
+
+    case "make": {
+      // :make - run build command (not implemented)
+      return { error: editor.t("error.use_terminal") };
+    }
+
+    case "ascii": {
+      // :ascii - show ASCII value of char under cursor
+      return { message: editor.t("info.status_bar_char") };
+    }
+
+    default: {
+      return { error: editor.t("error.unknown_command", { cmd: command }) };
+    }
+  }
+}
+
+// Go to a specific line number
+async function gotoLine(lineNum: number): Promise<CommandResult> {
+  if (lineNum < 1) {
+    return { error: editor.t("error.line_must_be_positive") };
+  }
+
+  const bufferId = editor.getActiveBufferId();
+  const bufferLength = editor.getBufferLength(bufferId);
+
+  // Get the text to find the line offset
+  const text = await editor.getBufferText(bufferId, 0, bufferLength);
+  if (!text) {
+    return { error: editor.t("error.cannot_read_buffer") };
+  }
+
+  let lineStart = 0;
+  let currentLine = 1;
+
+  for (let i = 0; i < text.length && currentLine < lineNum; i++) {
+    if (text[i] === '\n') {
+      currentLine++;
+      lineStart = i + 1;
+    }
+  }
+
+  if (currentLine >= lineNum || lineStart < text.length) {
+    editor.setBufferCursor(bufferId, lineStart);
+    return {};
+  }
+
+  // If requested line is beyond file, go to last line
+  editor.executeAction("move_document_end");
+  return { message: editor.t("status.line_beyond_end", { line: String(lineNum) }) };
+}
+
+// Handle :set command options
+function handleSetCommand(args: string): CommandResult {
+  const parts = args.split("=");
+  const option = parts[0].trim();
+  const value = parts.length > 1 ? parts[1].trim() : null;
+
+  switch (option) {
+    case "number":
+    case "nu": {
+      // :set number - show line numbers
+      const bufferId = editor.getActiveBufferId();
+      editor.setLineNumbers(bufferId, true);
+      return { message: editor.t("status.line_numbers_on") };
+    }
+
+    case "nonumber":
+    case "nonu": {
+      // :set nonumber - hide line numbers
+      const bufferId = editor.getActiveBufferId();
+      editor.setLineNumbers(bufferId, false);
+      return { message: editor.t("status.line_numbers_off") };
+    }
+
+    case "wrap": {
+      // :set wrap - enable line wrap
+      editor.executeAction("toggle_wrap");
+      return { message: editor.t("status.line_wrap_toggled") };
+    }
+
+    case "nowrap": {
+      // :set nowrap - disable line wrap
+      editor.executeAction("toggle_wrap");
+      return { message: editor.t("status.line_wrap_toggled") };
+    }
+
+    default: {
+      return { error: editor.t("error.unknown_option", { option }) };
+    }
+  }
+}
+
+// Register event handler for prompt confirmation
+editor.on("prompt_confirmed", "vi_command_handler");
+
 // ============================================================================
 // Toggle Command
 // ============================================================================
@@ -1607,18 +2724,18 @@ globalThis.vi_mode_toggle = function (): void {
 
   if (viModeEnabled) {
     switchMode("normal");
-    editor.setStatus("Vi mode enabled - NORMAL");
+    editor.setStatus(editor.t("status.enabled"));
   } else {
     editor.setEditorMode(null);
     state.mode = "normal";
     state.pendingOperator = null;
-    editor.setStatus("Vi mode disabled");
+    editor.setStatus(editor.t("status.disabled"));
   }
 };
 
 editor.registerCommand(
-  "Toggle Vi mode",
-  "Enable or disable vi-style modal editing",
+  "%cmd.toggle_vi_mode",
+  "%cmd.toggle_vi_mode_desc",
   "vi_mode_toggle",
   "normal",
 );
@@ -1627,4 +2744,4 @@ editor.registerCommand(
 // Initialization
 // ============================================================================
 
-editor.setStatus("Vi mode plugin loaded. Use 'Toggle Vi mode' command to enable.");
+editor.setStatus(editor.t("status.loaded"));