@ncukondo/gcal-cli 0.2.2 → 0.3.0

package/dist/index.js

@@ -6,25 +6,43 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
@@ -587718,7 +587736,7 @@ function errorCodeToExitCode(code) {
 // package.json
 var package_default = {
   name: "@ncukondo/gcal-cli",
-  version: "0.2.2",
+  version: "0.3.0",
   type: "module",
   exports: {
     ".": "./dist/index.js"
@@ -588406,7 +588424,6 @@ function applyFilters(events, options) {
   const afterTransparency = filterByTransparency(events, options.transparency);
   return filterByStatus(afterTransparency, options);
 }
-
 // node_modules/date-fns/locale/en-US/_lib/formatDistance.mjs
 var formatDistanceLocale = {
   lessThanXSeconds: {
@@ -590579,7 +590596,7 @@ function parseDateTimeInZone(dateStr, timezone) {
 // src/commands/search.ts
 var DEFAULT_SEARCH_DAYS = 30;
 async function handleSearch(opts) {
-  const { api: api2, query, format: format3, calendars, timezone, write } = opts;
+  const { api: api2, query, format: format4, calendars, timezone, write } = opts;
   const writeErr = opts.writeErr ?? (() => {});
   const now = new Date;
   const days = opts.days ?? DEFAULT_SEARCH_DAYS;
@@ -590625,7 +590642,7 @@ async function handleSearch(opts) {
   if (opts.includeTentative !== undefined)
     filterOpts.includeTentative = opts.includeTentative;
   const filtered = applyFilters(allEvents, filterOpts);
-  if (format3 === "json") {
+  if (format4 === "json") {
     write(formatJsonSuccess({
       query,
       events: filtered,
@@ -590656,10 +590673,10 @@ function createSearchCommand() {
 
 // src/commands/show.ts
 async function handleShow(opts) {
-  const { api: api2, eventId, calendarId, calendarName, format: format3, timezone, write } = opts;
+  const { api: api2, eventId, calendarId, calendarName, format: format4, timezone, write } = opts;
   try {
     const event = await getEvent(api2, calendarId, calendarName, eventId, timezone);
-    if (format3 === "json") {
+    if (format4 === "json") {
       write(formatJsonSuccess({ event }));
     } else {
       write(formatEventDetailText(event));
@@ -590667,7 +590684,7 @@ async function handleShow(opts) {
     return { exitCode: ExitCode.SUCCESS };
   } catch (error) {
     if (error instanceof ApiError) {
-      if (format3 === "json") {
+      if (format4 === "json") {
         write(formatJsonError(error.code, error.message));
       } else {
         write(`Error: ${error.message}`);
@@ -591733,19 +591750,19 @@ function resolveDateRange(input, timezone, now = () => new Date) {
   }
   if (input.from) {
     const fromDate = parseDateTimeInZone(input.from, timezone);
-    const toDate3 = input.to ? addDays(parseDateTimeInZone(input.to, timezone), 1) : addDays(fromDate, 7);
+    const toDate4 = input.to ? addDays(parseDateTimeInZone(input.to, timezone), 1) : addDays(fromDate, 7);
     return {
       timeMin: formatDateTimeInZone(fromDate, timezone),
-      timeMax: formatDateTimeInZone(toDate3, timezone)
+      timeMax: formatDateTimeInZone(toDate4, timezone)
     };
   }
   if (input.to) {
     const todayStr2 = todayInZone(now(), timezone);
     const fromDate = parseDateTimeInZone(todayStr2, timezone);
-    const toDate3 = addDays(parseDateTimeInZone(input.to, timezone), 1);
+    const toDate4 = addDays(parseDateTimeInZone(input.to, timezone), 1);
     return {
       timeMin: formatDateTimeInZone(fromDate, timezone),
-      timeMax: formatDateTimeInZone(toDate3, timezone),
+      timeMax: formatDateTimeInZone(toDate4, timezone),
       warning: "--from not specified, defaulting to today"
     };
   }
@@ -591856,10 +591873,194 @@ function createListCommand() {
   return cmd;
 }
 
+// src/lib/date-utils.ts
+var DATE_ONLY_RE2 = /^\d{4}-\d{2}-\d{2}$/;
+function isDateOnly(input) {
+  if (!DATE_ONLY_RE2.test(input))
+    return false;
+  const [y, m, d] = input.split("-").map(Number);
+  const date3 = new Date(Date.UTC(y, m - 1, d));
+  return date3.getUTCFullYear() === y && date3.getUTCMonth() === m - 1 && date3.getUTCDate() === d;
+}
+function addDaysToDateString(dateStr, days) {
+  const [y, m, d] = dateStr.split("-").map(Number);
+  const date3 = new Date(Date.UTC(y, m - 1, d + days));
+  return date3.toISOString().slice(0, 10);
+}
+
+// src/lib/duration.ts
+var DURATION_RE = /^(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?$/;
+function parseDuration(input) {
+  const match2 = DURATION_RE.exec(input);
+  if (!match2 || input === "") {
+    throw new Error(`Invalid duration: "${input}". Use formats like 30m, 1h, 2d, 1h30m.`);
+  }
+  const days = Number(match2[1] || 0);
+  const hours = Number(match2[2] || 0);
+  const minutes = Number(match2[3] || 0);
+  const ms = ((days * 24 + hours) * 60 + minutes) * 60 * 1000;
+  if (ms === 0) {
+    throw new Error("Duration must be greater than zero.");
+  }
+  return ms;
+}
+
 // src/commands/update.ts
+var MS_PER_DAY = 24 * 60 * 60 * 1000;
+function resolveTimedEvent(startStr, endStr, timezone) {
+  const parsedStart = parseDateTimeInZone(startStr, timezone);
+  const parsedEnd = parseDateTimeInZone(endStr, timezone);
+  return {
+    start: formatDateTimeInZone(parsedStart, timezone),
+    end: formatDateTimeInZone(parsedEnd, timezone),
+    allDay: false
+  };
+}
+function resolveAllDayEvent(startStr, endStr) {
+  return {
+    start: startStr,
+    end: addDaysToDateString(endStr, 1),
+    allDay: true
+  };
+}
+function resolveStartAndEnd(startStr, endStr, allDay, timezone) {
+  if (allDay) {
+    return resolveAllDayEvent(startStr, endStr);
+  }
+  return resolveTimedEvent(startStr, endStr, timezone);
+}
+function resolveStartAndDuration(startStr, durationMs, allDay, timezone) {
+  if (allDay) {
+    const days = durationMs / MS_PER_DAY;
+    return {
+      start: startStr,
+      end: addDaysToDateString(startStr, days),
+      allDay: true
+    };
+  }
+  const parsedStart = parseDateTimeInZone(startStr, timezone);
+  const endDate = new Date(parsedStart.getTime() + durationMs);
+  return {
+    start: formatDateTimeInZone(parsedStart, timezone),
+    end: formatDateTimeInZone(endDate, timezone),
+    allDay: false
+  };
+}
+function resolveStartOnly(startStr, existing, allDay, timezone) {
+  if (allDay) {
+    const existingStartMs2 = new Date(existing.start).getTime();
+    const existingEndMs2 = new Date(existing.end).getTime();
+    const durationDays = Math.round((existingEndMs2 - existingStartMs2) / MS_PER_DAY);
+    return {
+      start: startStr,
+      end: addDaysToDateString(startStr, durationDays),
+      allDay: true,
+      existingEvent: existing
+    };
+  }
+  const existingStartMs = new Date(existing.start).getTime();
+  const existingEndMs = new Date(existing.end).getTime();
+  const durationMs = existingEndMs - existingStartMs;
+  const parsedStart = parseDateTimeInZone(startStr, timezone);
+  const endDate = new Date(parsedStart.getTime() + durationMs);
+  return {
+    start: formatDateTimeInZone(parsedStart, timezone),
+    end: formatDateTimeInZone(endDate, timezone),
+    allDay: false,
+    existingEvent: existing
+  };
+}
+function resolveEndOnly(endStr, existing, allDay, timezone) {
+  if (allDay) {
+    return {
+      start: existing.start,
+      end: addDaysToDateString(endStr, 1),
+      allDay: true,
+      existingEvent: existing
+    };
+  }
+  const parsedEnd = parseDateTimeInZone(endStr, timezone);
+  return {
+    start: existing.start,
+    end: formatDateTimeInZone(parsedEnd, timezone),
+    allDay: false,
+    existingEvent: existing
+  };
+}
+function resolveDurationOnly(durationMs, existing, allDay, timezone) {
+  if (allDay) {
+    const days = durationMs / MS_PER_DAY;
+    return {
+      start: existing.start,
+      end: addDaysToDateString(existing.start, days),
+      allDay: true,
+      existingEvent: existing
+    };
+  }
+  const existingStartMs = new Date(existing.start).getTime();
+  const endDate = new Date(existingStartMs + durationMs);
+  return {
+    start: existing.start,
+    end: formatDateTimeInZone(endDate, timezone),
+    allDay: false,
+    existingEvent: existing
+  };
+}
+async function resolveTimeUpdate(opts) {
+  const { timezone, calendarId, calendarName, eventId, getEvent: getEvent2 } = opts;
+  const hasStart = opts.start !== undefined;
+  const hasEnd = opts.end !== undefined;
+  const hasDuration = opts.duration !== undefined;
+  if (!hasStart && !hasEnd && !hasDuration)
+    return null;
+  const durationMs = hasDuration ? parseDuration(opts.duration) : undefined;
+  const needExisting = hasStart && !hasEnd && !hasDuration || hasEnd && !hasStart || hasDuration && !hasStart;
+  let existing;
+  if (needExisting) {
+    existing = await getEvent2(calendarId, calendarName, eventId, timezone);
+  }
+  const allDay = hasStart ? isDateOnly(opts.start) : existing.all_day;
+  if (hasStart && hasEnd) {
+    const startIsDateOnly = isDateOnly(opts.start);
+    const endIsDateOnly = isDateOnly(opts.end);
+    if (startIsDateOnly !== endIsDateOnly) {
+      throw new ApiError("INVALID_ARGS", "--start and --end must be the same type (both date-only or both datetime)");
+    }
+  }
+  if (hasEnd && !hasStart && existing) {
+    const endIsDateOnly = isDateOnly(opts.end);
+    if (existing.all_day && !endIsDateOnly) {
+      throw new ApiError("INVALID_ARGS", "--end format (datetime) does not match existing event type (all-day). Use date-only format (YYYY-MM-DD) or provide --start to change event type.");
+    }
+    if (!existing.all_day && endIsDateOnly) {
+      throw new ApiError("INVALID_ARGS", "--end format (date-only) does not match existing event type (timed). Use datetime format (YYYY-MM-DDTHH:MM) or provide --start to change event type.");
+    }
+  }
+  if (durationMs !== undefined && allDay) {
+    if (durationMs % MS_PER_DAY !== 0) {
+      throw new ApiError("INVALID_ARGS", "All-day events require day-unit duration (e.g. 1d, 2d). Sub-day durations like hours or minutes are not allowed.");
+    }
+  }
+  if (hasStart && hasEnd) {
+    return resolveStartAndEnd(opts.start, opts.end, allDay, timezone);
+  }
+  if (hasStart && durationMs !== undefined) {
+    return resolveStartAndDuration(opts.start, durationMs, allDay, timezone);
+  }
+  if (hasStart) {
+    return resolveStartOnly(opts.start, existing, allDay, timezone);
+  }
+  if (hasEnd) {
+    return resolveEndOnly(opts.end, existing, allDay, timezone);
+  }
+  if (durationMs !== undefined) {
+    return resolveDurationOnly(durationMs, existing, allDay, timezone);
+  }
+  return null;
+}
 async function handleUpdate(opts) {
-  const { api: api2, eventId, calendarId, calendarName, format: format3, timezone, write } = opts;
-  const hasUpdate = opts.title !== undefined || opts.start !== undefined || opts.end !== undefined || opts.description !== undefined || opts.busy !== undefined || opts.free !== undefined;
+  const { api: api2, eventId, calendarId, calendarName, format: format4, timezone, write } = opts;
+  const hasUpdate = opts.title !== undefined || opts.start !== undefined || opts.end !== undefined || opts.duration !== undefined || opts.description !== undefined || opts.busy !== undefined || opts.free !== undefined;
   if (!hasUpdate) {
     throw new ApiError("INVALID_ARGS", "at least one update option must be provided");
   }
@@ -591875,19 +592076,21 @@ async function handleUpdate(opts) {
   } else if (opts.free) {
     input.transparency = "transparent";
   }
-  if (opts.start !== undefined || opts.end !== undefined) {
-    if (opts.start === undefined || opts.end === undefined) {
-      throw new ApiError("INVALID_ARGS", "start, end, and allDay must all be provided together");
-    }
-    const startStr = opts.start;
-    const endStr = opts.end;
-    const parsedStart = parseDateTimeInZone(startStr, timezone);
-    const parsedEnd = parseDateTimeInZone(endStr, timezone);
+  const timeResult = await resolveTimeUpdate(opts);
+  if (timeResult) {
     const withTime = input;
-    withTime.start = formatDateTimeInZone(parsedStart, timezone);
-    withTime.end = formatDateTimeInZone(parsedEnd, timezone);
-    withTime.allDay = false;
+    withTime.start = timeResult.start;
+    withTime.end = timeResult.end;
+    withTime.allDay = timeResult.allDay;
     input.timeZone = timezone;
+    if (timeResult.existingEvent) {
+      const existing = timeResult.existingEvent;
+      if (existing.all_day && !timeResult.allDay) {
+        opts.writeStderr("⚠ Event type changed from all-day to timed");
+      } else if (!existing.all_day && timeResult.allDay) {
+        opts.writeStderr("⚠ Event type changed from timed to all-day");
+      }
+    }
   }
   if (opts.dryRun) {
     const changes = {};
@@ -591902,7 +592105,9 @@ async function handleUpdate(opts) {
       changes.start = withTime.start;
     if (withTime.end !== undefined)
       changes.end = withTime.end;
-    if (format3 === "json") {
+    if (withTime.allDay !== undefined)
+      changes.allDay = withTime.allDay;
+    if (format4 === "json") {
       write(formatJsonSuccess({
         dry_run: true,
         action: "update",
@@ -591927,7 +592132,7 @@ async function handleUpdate(opts) {
     return { exitCode: ExitCode.SUCCESS };
   }
   const updated = await updateEvent(api2, calendarId, calendarName, eventId, input);
-  if (format3 === "json") {
+  if (format4 === "json") {
     write(formatJsonSuccess({ event: updated }));
   } else {
     write(formatEventDetailText(updated));
@@ -591938,16 +592143,34 @@ function createUpdateCommand() {
   const cmd = new Command("update").description("Update an existing event").argument("<event-id>", "Event ID to update");
   cmd.option("-c, --calendar <id>", "Calendar ID");
   cmd.option("-t, --title <title>", "New title");
-  cmd.option("-s, --start <datetime>", "New start datetime");
-  cmd.option("-e, --end <datetime>", "New end datetime");
+  cmd.option("-s, --start <datetime>", "Start date or datetime. Date-only (YYYY-MM-DD) → all-day. Datetime (YYYY-MM-DDTHH:MM) → timed. Can be specified alone (preserves existing duration).");
+  cmd.option("-e, --end <datetime>", "End date or datetime. Can be specified alone (preserves existing start). All-day end is inclusive.");
+  cmd.option("--duration <duration>", "Duration instead of --end (e.g. 30m, 1h, 2d, 1h30m). Mutually exclusive with --end. Can be specified alone (preserves existing start).");
   cmd.option("-d, --description <text>", "New description");
   cmd.option("--busy", "Mark as busy");
   cmd.option("--free", "Mark as free");
   cmd.option("--dry-run", "Preview without executing");
+  const endOpt = cmd.options.find((o) => o.long === "--end");
+  const durationOpt = cmd.options.find((o) => o.long === "--duration");
+  endOpt.conflicts(["duration"]);
+  durationOpt.conflicts(["end"]);
   const busyOpt = cmd.options.find((o) => o.long === "--busy");
   const freeOpt = cmd.options.find((o) => o.long === "--free");
   busyOpt.conflicts(["free"]);
   freeOpt.conflicts(["busy"]);
+  cmd.addHelpText("after", `
+Examples:
+  gcal update abc123 -t "Updated Meeting"                                    # Title only
+  gcal update abc123 -s "2026-01-24T11:00"                                   # Start only, keep duration
+  gcal update abc123 -e "2026-01-24T12:00"                                   # End only, keep start
+  gcal update abc123 --duration 2h                                           # Duration only, keep start
+  gcal update abc123 -s "2026-01-24T11:00" -e "2026-01-24T12:30"            # Start + end
+  gcal update abc123 -s "2026-01-24T10:00" --duration 30m                   # Start + duration
+  gcal update abc123 -s "2026-03-01" -e "2026-03-03"                        # All-day, 3 days (inclusive)
+  gcal update abc123 -s "2026-03-01" --duration 2d                          # All-day, 2 days
+  gcal update abc123 --free                                                  # Transparency only
+  gcal update abc123 --dry-run -t "Preview"                                  # Dry run
+`);
   return cmd;
 }
 
@@ -591961,10 +592184,18 @@ async function handleAdd(options, deps) {
     deps.write(formatJsonError("INVALID_ARGS", "--start is required"));
     return { exitCode: ExitCode.ARGUMENT };
   }
-  if (!options.end) {
-    deps.write(formatJsonError("INVALID_ARGS", "--end is required"));
+  if (options.end && options.duration) {
+    deps.write(formatJsonError("INVALID_ARGS", "--end and --duration cannot be used together"));
     return { exitCode: ExitCode.ARGUMENT };
   }
+  const allDay = isDateOnly(options.start);
+  if (options.end) {
+    const endIsDateOnly = isDateOnly(options.end);
+    if (allDay !== endIsDateOnly) {
+      deps.write(formatJsonError("INVALID_ARGS", "--start and --end must be the same type (both date-only or both datetime)"));
+      return { exitCode: ExitCode.ARGUMENT };
+    }
+  }
   const config2 = deps.loadConfig();
   const timezone = resolveTimezone(options.timezone, config2.timezone);
   const calendars = selectCalendars(options.calendar ? [options.calendar] : undefined, config2);
@@ -591976,20 +592207,54 @@ async function handleAdd(options, deps) {
     transparency = "transparent";
   let start;
   let end;
-  if (options.allDay) {
-    start = options.start.slice(0, 10);
-    end = options.end.slice(0, 10);
+  if (allDay) {
+    start = options.start;
+    if (options.end) {
+      end = addDaysToDateString(options.end, 1);
+    } else if (options.duration) {
+      let durationMs;
+      try {
+        durationMs = parseDuration(options.duration);
+      } catch {
+        deps.write(formatJsonError("INVALID_ARGS", `Invalid duration: "${options.duration}". Use formats like 30m, 1h, 2d, 1h30m.`));
+        return { exitCode: ExitCode.ARGUMENT };
+      }
+      const MS_PER_DAY2 = 24 * 60 * 60 * 1000;
+      if (durationMs % MS_PER_DAY2 !== 0) {
+        deps.write(formatJsonError("INVALID_ARGS", "All-day events require day-unit duration (e.g. 1d, 2d). Sub-day durations like hours or minutes are not allowed."));
+        return { exitCode: ExitCode.ARGUMENT };
+      }
+      const days = durationMs / MS_PER_DAY2;
+      end = addDaysToDateString(options.start, days);
+    } else {
+      end = addDaysToDateString(options.start, 1);
+    }
   } else {
     const startDate = parseDateTimeInZone(options.start, timezone);
-    const endDate = parseDateTimeInZone(options.end, timezone);
     start = formatDateTimeInZone(startDate, timezone);
-    end = formatDateTimeInZone(endDate, timezone);
+    if (options.end) {
+      const endDate = parseDateTimeInZone(options.end, timezone);
+      end = formatDateTimeInZone(endDate, timezone);
+    } else if (options.duration) {
+      let durationMs;
+      try {
+        durationMs = parseDuration(options.duration);
+      } catch {
+        deps.write(formatJsonError("INVALID_ARGS", `Invalid duration: "${options.duration}". Use formats like 30m, 1h, 2d, 1h30m.`));
+        return { exitCode: ExitCode.ARGUMENT };
+      }
+      const endDate = new Date(startDate.getTime() + durationMs);
+      end = formatDateTimeInZone(endDate, timezone);
+    } else {
+      const endDate = new Date(startDate.getTime() + 60 * 60 * 1000);
+      end = formatDateTimeInZone(endDate, timezone);
+    }
   }
   const input = {
     title: options.title,
     start,
     end,
-    allDay: options.allDay ?? false,
+    allDay,
     timeZone: timezone,
     transparency
   };
@@ -592009,29 +592274,43 @@ ${detail}`);
 }
 function createAddCommand() {
   const cmd = new Command("add").description("Create a new event");
-  cmd.option("-t, --title <title>", "Event title");
-  cmd.option("-s, --start <datetime>", "Start datetime (ISO 8601)");
-  cmd.option("-e, --end <datetime>", "End datetime (ISO 8601)");
-  cmd.option("--all-day", "Create all-day event (use date only)");
+  cmd.requiredOption("-t, --title <title>", "Event title");
+  cmd.requiredOption("-s, --start <datetime>", "Start date or datetime. Date-only (YYYY-MM-DD) creates all-day event. Datetime (YYYY-MM-DDTHH:MM) creates timed event.");
+  cmd.option("-e, --end <datetime>", "End date or datetime. Optional. Default: same day (all-day) or +1h (timed). All-day end is inclusive.");
+  cmd.option("--duration <duration>", "Duration instead of --end (e.g. 30m, 1h, 2d, 1h30m). Mutually exclusive with --end.");
   cmd.option("-d, --description <text>", "Event description");
   cmd.option("--busy", "Mark as busy (default)");
   cmd.option("--free", "Mark as free (transparent)");
+  const endOpt = cmd.options.find((o) => o.long === "--end");
+  const durationOpt = cmd.options.find((o) => o.long === "--duration");
+  endOpt.conflicts(["duration"]);
+  durationOpt.conflicts(["end"]);
   const busyOpt = cmd.options.find((o) => o.long === "--busy");
   const freeOpt = cmd.options.find((o) => o.long === "--free");
   busyOpt.conflicts(["free"]);
   freeOpt.conflicts(["busy"]);
+  cmd.addHelpText("after", `
+Examples:
+  gcal add -t "Holiday" -s "2026-01-24"                                   # All-day, 1 day
+  gcal add -t "Vacation" -s "2026-01-24" -e "2026-01-26"                  # All-day, 3 days (inclusive)
+  gcal add -t "Camp" -s "2026-01-24" --duration 2d                        # All-day, 2 days
+  gcal add -t "Meeting" -s "2026-01-24T10:00"                             # Timed, 1h default
+  gcal add -t "Meeting" -s "2026-01-24T10:00" -e "2026-01-24T11:30"      # Timed, explicit end
+  gcal add -t "Standup" -s "2026-01-24T10:00" --duration 30m             # Timed, 30 min
+  gcal add -t "Focus" -s "2026-01-24T09:00" --duration 2h --free         # Timed, free
+`);
   return cmd;
 }
 
 // src/commands/delete.ts
 async function handleDelete(opts) {
-  const { api: api2, eventId, calendarId, format: format3, quiet, dryRun = false, write } = opts;
+  const { api: api2, eventId, calendarId, format: format4, quiet, dryRun = false, write } = opts;
   if (!eventId) {
     write(formatJsonError("INVALID_ARGS", "event-id is required"));
     return { exitCode: ExitCode.ARGUMENT };
   }
   if (dryRun) {
-    if (format3 === "json") {
+    if (format4 === "json") {
       write(formatJsonSuccess({
         dry_run: true,
         action: "delete",
@@ -592046,7 +592325,7 @@ async function handleDelete(opts) {
   try {
     await deleteEvent(api2, calendarId, eventId);
     if (!quiet) {
-      if (format3 === "json") {
+      if (format4 === "json") {
         write(formatJsonSuccess({ deleted_id: eventId, message: "Event deleted" }));
       } else {
         write("Event deleted");
@@ -592055,7 +592334,7 @@ async function handleDelete(opts) {
     return { exitCode: ExitCode.SUCCESS };
   } catch (error) {
     if (error instanceof ApiError) {
-      if (format3 === "json") {
+      if (format4 === "json") {
         write(formatJsonError(error.code, error.message));
       } else {
         write(`Error: ${error.message}`);
@@ -592081,13 +592360,13 @@ function mergeCalendarsWithConfig(apiCalendars, configCalendars) {
   });
 }
 async function handleCalendars(opts) {
-  const { api: api2, format: format3, quiet, write, configCalendars } = opts;
+  const { api: api2, format: format4, quiet, write, configCalendars } = opts;
   let apiCalendars;
   try {
     apiCalendars = await listCalendars(api2);
   } catch (error) {
     if (error instanceof ApiError) {
-      if (format3 === "json") {
+      if (format4 === "json") {
         write(formatJsonError(error.code, error.message));
       } else {
         write(error.message);
@@ -592102,7 +592381,7 @@ async function handleCalendars(opts) {
 `));
     return { exitCode: ExitCode.SUCCESS };
   }
-  if (format3 === "json") {
+  if (format4 === "json") {
     write(formatJsonSuccess({ calendars }));
   } else {
     write(formatCalendarListText(calendars));
@@ -592119,12 +592398,12 @@ function resolveTimezone2(cliTimezone) {
   return cliTimezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
 }
 async function handleInit(opts) {
-  const { fs, format: format3, quiet, write, force, all, local, requestAuth } = opts;
+  const { fs, format: format4, quiet, write, force, all, local, requestAuth } = opts;
   const configPath = local ? `${process.cwd()}/gcal-cli.toml` : getDefaultConfigPath();
   if (!force && fs.existsSync(configPath)) {
     const msg = `Config file already exists: ${configPath}
 Use --force to overwrite.`;
-    if (format3 === "json") {
+    if (format4 === "json") {
       write(formatJsonError("CONFIG_ERROR", msg));
     } else {
       write(msg);
@@ -592140,7 +592419,7 @@ Use --force to overwrite.`;
       calendars = await opts.listCalendars();
     } else if (isAuthRequiredError(error)) {
       const msg = "Not authenticated. Run `gcal auth` to authenticate.";
-      if (format3 === "json") {
+      if (format4 === "json") {
         write(formatJsonError("AUTH_REQUIRED", msg));
       } else {
         write(msg);
@@ -592152,7 +592431,7 @@ Use --force to overwrite.`;
   }
   if (calendars.length === 0) {
     const msg = "No calendars found in Google Calendar.";
-    if (format3 === "json") {
+    if (format4 === "json") {
       write(formatJsonError("API_ERROR", msg));
     } else {
       write(msg);
@@ -592174,7 +592453,7 @@ Use --force to overwrite.`;
     write(configPath);
     return { exitCode: ExitCode.SUCCESS };
   }
-  if (format3 === "json") {
+  if (format4 === "json") {
     write(formatJsonSuccess({
       path: configPath,
       timezone,
@@ -592293,10 +592572,10 @@ function getErrorCode2(error) {
   }
   return "API_ERROR";
 }
-function handleError2(error, format3) {
+function handleError2(error, format4) {
   const errorCode = getErrorCode2(error);
   const message2 = error instanceof Error ? error.message : String(error);
-  if (format3 === "json") {
+  if (format4 === "json") {
     process.stderr.write(formatJsonError(errorCode, message2));
   } else {
     process.stderr.write(`Error: ${message2}
@@ -592551,7 +592830,7 @@ ${url}`);
         title: addOpts.title,
         start: addOpts.start,
         end: addOpts.end,
-        allDay: addOpts.allDay,
+        duration: addOpts.duration,
         description: addOpts.description,
         busy: addOpts.busy,
         free: addOpts.free,
@@ -592648,6 +592927,9 @@ ${authUrl}`);
         timezone,
         write: (msg) => process.stdout.write(msg + `
 `),
+        writeStderr: (msg) => process.stderr.write(msg + `
+`),
+        getEvent: (calId, calName, evtId, tz) => getEvent(api2, calId, calName, evtId, tz),
         ...updateOpts
       });
       process.exit(result.exitCode);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ncukondo/gcal-cli",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"