Enhance sequence command with leading zeros preservation and max-length padding

- Add leading zeros preservation logic similar to increment/decrement commands
- Implement max-length consistent padding across all numbers in selection
- Add comprehensive test coverage for various zero padding scenarios
- Fixes issue #72: sequence command now maintains leading zero formatting

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: exceptionraiser

content.txt

@@ -62,3 +62,6 @@ prefix007 suffix008 middle009
 0009 0010 0001
 0001 0099 0000
 0007 0008 0009
+test01 value100 prefix007 99
+02 100 4
+010 100 123

src/commands/sequence.ts

@@ -4,11 +4,40 @@ export const sequence: CommandFunction = (
   str: string,
   multiselectData: MultiSelectData = {}
 ) => {
+  // First pass: find all numbers and determine the maximum length for zero padding
+  const numbers = Array.from(str.matchAll(/-?\d+/g));
+  const maxLength = Math.max(...numbers.map(match => {
+    const num = match[0];
+    // Only consider numbers with leading zeros for max length calculation
+    if (num.length > 1 && num.charAt(num.charAt(0) === '-' ? 1 : 0) === '0') {
+      return num.length;
+    }
+    return 0;
+  }));
+  
   return str.replace(/-?\d+/g, (n) => {
     const isFirst = typeof multiselectData.offset !== "number";
     multiselectData.offset = isFirst
       ? Number(n)
       : (multiselectData.offset || 0) + 1;
-    return String(multiselectData.offset);
+    
+    const sequenceValue = multiselectData.offset;
+    
+    // Use max length for consistent padding if any number in the string has leading zeros
+    if (maxLength > 0) {
+      const isNegative = sequenceValue < 0;
+      const sequenceStr = String(sequenceValue);
+      
+      if (isNegative) {
+        // For negative numbers, pad after the minus sign
+        const absStr = sequenceStr.substring(1);
+        return '-' + absStr.padStart(maxLength - 1, '0');
+      } else {
+        // For positive numbers, pad the entire string
+        return sequenceStr.padStart(maxLength, '0');
+      }
+    }
+    
+    return String(sequenceValue);
   });
 };

src/test/extension.test.ts

@@ -746,6 +746,152 @@ suite("Extension Test Suite", () => {
       );
     });
 
+    test("sequence preserves leading zeros", async () => {
+      const [output1, output2, output3] = await getTextForSelectionsByCommand(
+        "string-manipulation.sequence",
+        [
+          {
+            start: { line: 55, character: 0 },
+            end: { line: 55, character: 21 },
+          },
+          {
+            start: { line: 56, character: 0 },
+            end: { line: 56, character: 26 },
+          },
+          {
+            start: { line: 57, character: 0 },
+            end: { line: 57, character: 30 },
+          },
+        ]
+      );
+
+      assert.strictEqual(
+        output1 /* abc009 def010 ghi001 */,
+        "abc009 def010 ghi011"
+      );
+      assert.strictEqual(
+        output2 /* test001 value99 number000 */,
+        "test012 value013 number014"
+      );
+      assert.strictEqual(
+        output3 /* prefix007 suffix008 middle009 */,
+        "prefix015 suffix016 middle017"
+      );
+    });
+
+    test("sequence preserves leading zeros without prefixes", async () => {
+      const [output1, output2, output3] = await getTextForSelectionsByCommand(
+        "string-manipulation.sequence",
+        [
+          {
+            start: { line: 58, character: 0 },
+            end: { line: 58, character: 11 },
+          },
+          {
+            start: { line: 59, character: 0 },
+            end: { line: 59, character: 10 },
+          },
+          {
+            start: { line: 60, character: 0 },
+            end: { line: 60, character: 11 },
+          },
+        ]
+      );
+
+      assert.strictEqual(
+        output1 /* 009 010 001 */,
+        "009 010 011"
+      );
+      assert.strictEqual(
+        output2 /* 001 99 000 */,
+        "012 013 014"
+      );
+      assert.strictEqual(
+        output3 /* 007 008 009 */,
+        "015 016 017"
+      );
+    });
+
+    test("sequence preserves 3 leading zeros", async () => {
+      const [output1, output2, output3] = await getTextForSelectionsByCommand(
+        "string-manipulation.sequence",
+        [
+          {
+            start: { line: 61, character: 0 },
+            end: { line: 61, character: 14 },
+          },
+          {
+            start: { line: 62, character: 0 },
+            end: { line: 62, character: 14 },
+          },
+          {
+            start: { line: 63, character: 0 },
+            end: { line: 63, character: 14 },
+          },
+        ]
+      );
+
+      assert.strictEqual(
+        output1 /* 0009 0010 0001 */,
+        "0009 0010 0011"
+      );
+      assert.strictEqual(
+        output2 /* 0001 0099 0000 */,
+        "0012 0013 0014"
+      );
+      assert.strictEqual(
+        output3 /* 0007 0008 0009 */,
+        "0015 0016 0017"
+      );
+    });
+
+    test("sequence preserves leading zeros with mixed number formats", async () => {
+      const [output] = await getTextForSelectionsByCommand(
+        "string-manipulation.sequence",
+        [
+          {
+            start: { line: 64, character: 0 },
+            end: { line: 64, character: 28 },
+          },
+        ]
+      );
+
+      // Test with a mix of zero-padded and regular numbers
+      // Line 64 contains: "test01 value100 prefix007 99"  
+      // Max length is 3 from "prefix007", so all numbers should be padded to 3 digits
+      assert.strictEqual(
+        output /* test01 value100 prefix007 99 */,
+        "test001 value002 prefix003 004"
+      );
+    });
+
+    test("sequence uses max length for consistent zero padding", async () => {
+      const [output1, output2] = await getTextForSelectionsByCommand(
+        "string-manipulation.sequence",
+        [
+          {
+            start: { line: 65, character: 0 },
+            end: { line: 65, character: 8 },
+          },
+          {
+            start: { line: 66, character: 0 },
+            end: { line: 66, character: 11 },
+          },
+        ]
+      );
+
+      // Line 65: "02 100 4" - max length is 2 from "02", so all should be padded to 2 digits
+      assert.strictEqual(
+        output1 /* 02 100 4 */,
+        "02 03 04"
+      );
+      // Line 66: "010 100 123" - max length is 3 from "010", so all should be padded to 3 digits  
+      assert.strictEqual(
+        output2 /* 010 100 123 */,
+        "005 006 007"
+      );
+    });
+
     test("utf8ToChar converts Unicode escapes to characters", async () => {
       const [output] = await getTextForSelectionsByCommand(
         "string-manipulation.utf8ToChar",
@@ -784,7 +930,7 @@ suite("Extension Test Suite", () => {
       const input = "Hello, World!";
 
       test("maintains string length and lowercased content", async () => {
-        const [output] = await getTextForSelectionsByCommand(
+        await getTextForSelectionsByCommand(
           "string-manipulation.randomCase",
           [
             {