feat: accept human-friendly duration formats in prune --older-than (#24)

* Initial plan

* feat: add human-friendly duration format support to prune command

Co-authored-by: captainsafia <1857993+captainsafia@users.noreply.github.com>

* doc: update documentation to show human-friendly duration format support

Co-authored-by: captainsafia <1857993+captainsafia@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: captainsafia <1857993+captainsafia@users.noreply.github.com>

Author: Copilot

README.md

@@ -173,6 +173,8 @@ Remove worktrees older than a specific duration (bypasses merge check):
 
 **Note:** When using `--older-than`, the merge status check is bypassed, and all worktrees older than the specified duration will be removed. The `--base` flag cannot be used with `--older-than`.
 
+You can use human-friendly formats (e.g., `30d`, `2w`, `6M`, `1y`) or ISO 8601 duration format (e.g., `P30D`, `P2W`, `P6M`, `P1Y`):
+
 ```bash
 # Remove worktrees older than 30 days
 grove prune --older-than 30d
@@ -185,6 +187,9 @@ grove prune --older-than 1y
 
 # Preview what would be removed for worktrees older than 2 weeks
 grove prune --older-than 2w --dry-run
+
+# ISO 8601 format is also supported
+grove prune --older-than P30D
 ```
 
 ### Self-update

site/index.html

@@ -286,8 +286,10 @@ <h4>Prune worktrees</h4>
                 <pre><code>grove prune --dry-run</code></pre>
                 <p>Remove worktrees for branches merged to main:</p>
                 <pre><code>grove prune</code></pre>
-                <p>Remove worktrees older than 30 days (uses ISO 8601 duration format):</p>
-                <pre><code>grove prune --older-than P30D</code></pre>
+                <p>Remove worktrees older than 30 days (supports human-friendly or ISO 8601 format):</p>
+                <pre><code>grove prune --older-than 30d
+# or
+grove prune --older-than P30D</code></pre>
                 <p>Use a different base branch:</p>
                 <pre><code>grove prune --base develop</code></pre>
             </div>

src/commands/prune.ts

@@ -35,7 +35,7 @@ export function createPruneCommand(): Command {
     .option("-y, --yes", "Skip confirmation prompt", false)
     .option(
       "--older-than <duration>",
-      "Prune worktrees older than specified duration, bypassing merge check (use ISO 8601 format like P30D, P1Y, P2W, PT1H)",
+      "Prune worktrees older than specified duration, bypassing merge check (e.g., 30d, 2w, 6M, 1y, or ISO 8601 like P30D, P1Y)",
     )
     .action(async (options: PruneCommandOptions) => {
       try {

src/utils/index.ts

@@ -69,21 +69,105 @@ export function extractRepoName(gitUrl: string): string {
   return repoName;
 }
 
+/**
+ * Normalize human-friendly duration strings to ISO 8601 format.
+ * Accepts formats like: 30d, 2w, 6M, 1y, 12h, 30m
+ * Returns ISO 8601 format: P30D, P2W, P6M, P1Y, PT12H, PT30M
+ * Note: Uppercase M = months, lowercase m = minutes
+ */
+export function normalizeDuration(durationStr: string): string {
+  if (!durationStr || durationStr.trim() === '') {
+    return durationStr;
+  }
+
+  const normalized = durationStr.trim();
+  
+  // If it already starts with 'P', assume it's ISO 8601 format
+  if (normalized.toUpperCase().startsWith('P')) {
+    return normalized;
+  }
+
+  // Match patterns like: 30d, 2w, 6M, 1y, 12h, 30m
+  // Note: M (uppercase) = months, m (lowercase) = minutes
+  // Case-insensitive match, but we preserve the M/m distinction
+  const match = normalized.match(/^(\d+(?:\.\d+)?)\s*([dDwWMmyYhHsS])$/);
+  if (!match) {
+    // Return as-is if format doesn't match - let parseDuration handle error
+    return normalized;
+  }
+
+  const [, value, unit] = match;
+
+  // Map human-friendly units to ISO 8601 format
+  // Time units (h, H, m, s, S) need PT prefix
+  // Date units (d, D, w, W, M, y, Y) need P prefix
+  let iso8601Unit: string;
+  let isTimeUnit: boolean;
+  
+  switch (unit) {
+    case 'd':
+    case 'D':
+      iso8601Unit = 'D';
+      isTimeUnit = false;
+      break;
+    case 'w':
+    case 'W':
+      iso8601Unit = 'W';
+      isTimeUnit = false;
+      break;
+    case 'M':  // Uppercase M = months
+      iso8601Unit = 'M';
+      isTimeUnit = false;
+      break;
+    case 'y':
+    case 'Y':
+      iso8601Unit = 'Y';
+      isTimeUnit = false;
+      break;
+    case 'h':
+    case 'H':
+      iso8601Unit = 'H';
+      isTimeUnit = true;
+      break;
+    case 'm':  // Lowercase m = minutes
+      iso8601Unit = 'M';
+      isTimeUnit = true;
+      break;
+    case 's':
+    case 'S':
+      iso8601Unit = 'S';
+      isTimeUnit = true;
+      break;
+    default:
+      return normalized;
+  }
+
+  // Time units need PT prefix, date units need P prefix
+  if (isTimeUnit) {
+    return `PT${value}${iso8601Unit}`;
+  } else {
+    return `P${value}${iso8601Unit}`;
+  }
+}
+
 export function parseDuration(durationStr: string): number {
   if (!durationStr || durationStr.trim() === '') {
-    throw new Error('Duration cannot be empty (use ISO 8601 duration format like P30D, P1Y, P2W, PT1H)');
+    throw new Error('Duration cannot be empty (use formats like: 30d, 2w, 6M, 1y, 12h, 30m or ISO 8601 like P30D, P1Y, P2W, PT1H)');
   }
 
+  // Normalize human-friendly format to ISO 8601
+  const normalized = normalizeDuration(durationStr);
+
   try {
-    const duration = moment.duration(durationStr.toUpperCase());
+    const duration = moment.duration(normalized.toUpperCase());
     if (duration.asMilliseconds() > 0) {
       return duration.asMilliseconds();
     } else {
       throw new Error(`Invalid or zero duration: ${durationStr}`);
     }
   } catch (error) {
     throw new Error(
-      `Invalid duration format: ${durationStr} (use ISO 8601 duration format like P30D, P1Y, P2W, PT1H)`,
+      `Invalid duration format: ${durationStr} (use formats like: 30d, 2w, 6M, 1y, 12h, 30m or ISO 8601 like P30D, P1Y, P2W, PT1H)`,
     );
   }
 }

test/unit/utils.test.ts

@@ -2,6 +2,7 @@ import { describe, test, expect } from "bun:test";
 import {
   extractRepoName,
   parseDuration,
+  normalizeDuration,
   formatCreatedTime,
   formatPathWithTilde,
   isValidGitUrl,
@@ -219,6 +220,86 @@ describe("isValidGitUrl", () => {
   });
 });
 
+describe("normalizeDuration", () => {
+  describe("Human-friendly formats", () => {
+    test("should normalize days (30d to P30D)", () => {
+      expect(normalizeDuration("30d")).toBe("P30D");
+    });
+
+    test("should normalize weeks (2w to P2W)", () => {
+      expect(normalizeDuration("2w")).toBe("P2W");
+    });
+
+    test("should normalize months (6M to P6M)", () => {
+      expect(normalizeDuration("6M")).toBe("P6M");
+    });
+
+    test("should normalize years (1y to P1Y)", () => {
+      expect(normalizeDuration("1y")).toBe("P1Y");
+    });
+
+    test("should normalize hours (12h to PT12H)", () => {
+      expect(normalizeDuration("12h")).toBe("PT12H");
+    });
+
+    test("should normalize minutes (30m to PT30M)", () => {
+      expect(normalizeDuration("30m")).toBe("PT30M");
+    });
+
+    test("should normalize seconds (45s to PT45S)", () => {
+      expect(normalizeDuration("45s")).toBe("PT45S");
+    });
+
+    test("should handle uppercase units", () => {
+      expect(normalizeDuration("30D")).toBe("P30D");
+    });
+
+    test("should handle lowercase units", () => {
+      expect(normalizeDuration("2w")).toBe("P2W");
+    });
+
+    test("should handle whitespace between number and unit", () => {
+      expect(normalizeDuration("30 d")).toBe("P30D");
+    });
+
+    test("should handle decimal values", () => {
+      expect(normalizeDuration("1.5d")).toBe("P1.5D");
+    });
+  });
+
+  describe("ISO 8601 formats (should pass through)", () => {
+    test("should pass through P30D unchanged", () => {
+      expect(normalizeDuration("P30D")).toBe("P30D");
+    });
+
+    test("should pass through P2W unchanged", () => {
+      expect(normalizeDuration("P2W")).toBe("P2W");
+    });
+
+    test("should pass through PT1H unchanged", () => {
+      expect(normalizeDuration("PT1H")).toBe("PT1H");
+    });
+
+    test("should pass through lowercase p30d", () => {
+      expect(normalizeDuration("p30d")).toBe("p30d");
+    });
+  });
+
+  describe("Invalid formats (should pass through for parseDuration to handle)", () => {
+    test("should pass through empty string", () => {
+      expect(normalizeDuration("")).toBe("");
+    });
+
+    test("should pass through invalid format", () => {
+      expect(normalizeDuration("30 days")).toBe("30 days");
+    });
+
+    test("should pass through number without unit", () => {
+      expect(normalizeDuration("30")).toBe("30");
+    });
+  });
+});
+
 describe("parseDuration", () => {
   describe("Valid ISO 8601 durations", () => {
     test("should parse days (P30D)", () => {
@@ -264,6 +345,55 @@ describe("parseDuration", () => {
     });
   });
 
+  describe("Human-friendly formats", () => {
+    test("should parse days (30d)", () => {
+      const result = parseDuration("30d");
+      expect(result).toBe(30 * 24 * 60 * 60 * 1000);
+    });
+
+    test("should parse weeks (2w)", () => {
+      const result = parseDuration("2w");
+      expect(result).toBe(14 * 24 * 60 * 60 * 1000);
+    });
+
+    test("should parse months (6M)", () => {
+      const result = parseDuration("6M");
+      // Moment calculates months, approximately 182 days for 6 months
+      expect(result).toBeGreaterThan(15500000000);
+      expect(result).toBeLessThan(16000000000);
+    });
+
+    test("should parse years (1y)", () => {
+      const result = parseDuration("1y");
+      expect(result).toBe(365 * 24 * 60 * 60 * 1000);
+    });
+
+    test("should parse hours (12h)", () => {
+      const result = parseDuration("12h");
+      expect(result).toBe(12 * 60 * 60 * 1000);
+    });
+
+    test("should parse minutes (30m)", () => {
+      const result = parseDuration("30m");
+      expect(result).toBe(30 * 60 * 1000);
+    });
+
+    test("should parse seconds (45s)", () => {
+      const result = parseDuration("45s");
+      expect(result).toBe(45 * 1000);
+    });
+
+    test("should handle uppercase human-friendly format", () => {
+      const result = parseDuration("30D");
+      expect(result).toBe(30 * 24 * 60 * 60 * 1000);
+    });
+
+    test("should handle whitespace in human-friendly format", () => {
+      const result = parseDuration("30 d");
+      expect(result).toBe(30 * 24 * 60 * 60 * 1000);
+    });
+  });
+
   describe("Error cases", () => {
     test("should throw for empty string", () => {
       expect(() => parseDuration("")).toThrow("Duration cannot be empty");