@ncukondo/gcal-cli 0.2.3 → 0.4.0

package/dist/index.js

@@ -587668,6 +587668,24 @@ function formatSearchResultText(query, events) {
   return lines.join(`
 `);
 }
+function formatQuietText(events) {
+  if (events.length === 0)
+    return "No events found.";
+  const lines = [];
+  for (const event of events) {
+    const month = event.start.slice(5, 7);
+    const day = event.start.slice(8, 10);
+    const datePrefix = `${month}/${day}`;
+    if (event.all_day) {
+      lines.push(`${datePrefix} All day      ${event.title}`);
+    } else {
+      const time3 = formatTimeRange(event);
+      lines.push(`${datePrefix} ${time3}  ${event.title}`);
+    }
+  }
+  return lines.join(`
+`);
+}
 var CALENDAR_ID_MAX = 15;
 var CALENDAR_ID_COL = 18;
 function truncateId(id) {
@@ -587736,7 +587754,7 @@ function errorCodeToExitCode(code) {
 // package.json
 var package_default = {
   name: "@ncukondo/gcal-cli",
-  version: "0.2.3",
+  version: "0.4.0",
   type: "module",
   exports: {
     ".": "./dist/index.js"
@@ -587790,12 +587808,9 @@ var package_default = {
 
 // src/cli.ts
 var FormatSchema = _enum(["text", "json"]);
-function collect(value, previous) {
-  return [...previous, value];
-}
 function createProgram() {
   const program2 = new Command;
-  program2.name("gcal").description("CLI tool for managing Google Calendar events").version(package_default.version).option("-f, --format <format>", "Output format: text | json", "text").option("-c, --calendar <id>", "Target calendar ID (repeatable)", collect, []).option("-q, --quiet", "Minimal output", false).option("--tz, --timezone <zone>", "Timezone (e.g., Asia/Tokyo)");
+  program2.name("gcal").description("CLI tool for managing Google Calendar events").version(package_default.version).option("-f, --format <format>", "Output format: text | json", "text").option("-q, --quiet", "Minimal output", false).option("--tz, --timezone <zone>", "Timezone (e.g., Asia/Tokyo)");
   program2.on("command:*", (operands) => {
     process.stderr.write(`error: unknown command '${operands[0]}'
 
@@ -587815,7 +587830,6 @@ function resolveGlobalOptions(program2) {
   }
   return {
     format: formatResult.data,
-    calendar: raw.calendar,
     timezone: raw.timezone,
     quiet: raw.quiet
   };
@@ -588424,6 +588438,61 @@ function applyFilters(events, options) {
   const afterTransparency = filterByTransparency(events, options.transparency);
   return filterByStatus(afterTransparency, options);
 }
+
+// src/commands/shared.ts
+import * as nodeFs from "node:fs";
+var fsAdapter = {
+  existsSync: (p) => nodeFs.existsSync(p),
+  readFileSync: (p) => nodeFs.readFileSync(p, "utf-8"),
+  writeFileSync: (p, d) => nodeFs.writeFileSync(p, d, "utf-8"),
+  mkdirSync: (p) => nodeFs.mkdirSync(p, { recursive: true }),
+  unlinkSync: (p) => nodeFs.unlinkSync(p),
+  chmodSync: (p, m) => nodeFs.chmodSync(p, m)
+};
+function collect(value, previous) {
+  return [...previous, value];
+}
+function createGoogleCalendarApi(calendar) {
+  return {
+    calendarList: {
+      list: async (p) => {
+        const res = await calendar.calendarList.list(p);
+        const data = {};
+        if (res.data.items)
+          data.items = res.data.items;
+        if (res.data.nextPageToken)
+          data.nextPageToken = res.data.nextPageToken;
+        return { data };
+      }
+    },
+    events: {
+      list: async (p) => {
+        const res = await calendar.events.list(p);
+        const data = {};
+        if (res.data.items)
+          data.items = res.data.items;
+        if (res.data.nextPageToken)
+          data.nextPageToken = res.data.nextPageToken;
+        return { data };
+      },
+      get: async (p) => {
+        const res = await calendar.events.get(p);
+        return { data: res.data };
+      },
+      insert: async (p) => {
+        const res = await calendar.events.insert(p);
+        return { data: res.data };
+      },
+      patch: async (p) => {
+        const res = await calendar.events.patch(p);
+        return { data: res.data };
+      },
+      delete: async (p) => {
+        await calendar.events.delete(p);
+      }
+    }
+  };
+}
 // node_modules/date-fns/locale/en-US/_lib/formatDistance.mjs
 var formatDistanceLocale = {
   lessThanXSeconds: {
@@ -590596,8 +590665,8 @@ function parseDateTimeInZone(dateStr, timezone) {
 // src/commands/search.ts
 var DEFAULT_SEARCH_DAYS = 30;
 async function handleSearch(opts) {
-  const { api: api2, query, format: format4, calendars, timezone, write } = opts;
-  const writeErr = opts.writeErr ?? (() => {});
+  const { api: api2, query, format: format4, calendars, timezone, write, quiet } = opts;
+  const writeErr = quiet ? () => {} : opts.writeErr ?? (() => {});
   const now = new Date;
   const days = opts.days ?? DEFAULT_SEARCH_DAYS;
   const isNegativeDays = days < 0;
@@ -590605,7 +590674,7 @@ async function handleSearch(opts) {
   let timeMax;
   if (opts.from && opts.to) {
     timeMin = formatDateTimeInZone(parseDateTimeInZone(opts.from, timezone), timezone);
-    timeMax = formatDateTimeInZone(parseDateTimeInZone(opts.to + "T23:59:59", timezone), timezone);
+    timeMax = formatDateTimeInZone(addDays(parseDateTimeInZone(opts.to, timezone), 1), timezone);
   } else if (opts.from) {
     const startDate = parseDateTimeInZone(opts.from, timezone);
     timeMin = formatDateTimeInZone(startDate, timezone);
@@ -590613,7 +590682,7 @@ async function handleSearch(opts) {
     endDate.setDate(endDate.getDate() + days);
     timeMax = formatDateTimeInZone(endDate, timezone);
   } else if (opts.to) {
-    timeMax = formatDateTimeInZone(parseDateTimeInZone(opts.to + "T23:59:59", timezone), timezone);
+    timeMax = formatDateTimeInZone(addDays(parseDateTimeInZone(opts.to, timezone), 1), timezone);
     timeMin = formatDateTimeInZone(now, timezone);
   } else if (isNegativeDays) {
     const pastDate = new Date(now.getTime());
@@ -590627,7 +590696,7 @@ async function handleSearch(opts) {
     timeMax = formatDateTimeInZone(endDate, timezone);
   }
   const displayFrom = timeMin.slice(0, 10);
-  const displayTo = timeMax.slice(0, 10);
+  const displayTo = opts.to ?? timeMax.slice(0, 10);
   writeErr(`Searching: ${displayFrom} to ${displayTo}`);
   const hasExplicitRange = opts.days !== undefined || opts.from !== undefined || opts.to !== undefined;
   if (!hasExplicitRange) {
@@ -590648,6 +590717,8 @@ async function handleSearch(opts) {
       events: filtered,
       count: filtered.length
     }));
+  } else if (quiet) {
+    write(formatQuietText(filtered));
   } else {
     write(formatSearchResultText(query, filtered));
   }
@@ -590655,9 +590726,10 @@ async function handleSearch(opts) {
 }
 function createSearchCommand() {
   const cmd = new Command("search").description("Search events by keyword").argument("<query>", "Search query string");
+  cmd.option("-c, --calendar <id>", "Target calendar ID (repeatable)", collect, []);
   cmd.option("--from <date>", "Start date for search range");
   cmd.option("--to <date>", "End date for search range");
-  cmd.option("--days <n>", "Search within next n days (default: 30)", Number.parseInt);
+  cmd.option("--days <n>", "Search within next n days (default: 30)", (v) => Number.parseInt(v, 10));
   const daysOpt = cmd.options.find((o) => o.long === "--days");
   const fromOpt = cmd.options.find((o) => o.long === "--from");
   const toOpt = cmd.options.find((o) => o.long === "--to");
@@ -590667,32 +590739,26 @@ function createSearchCommand() {
   cmd.option("--busy", "Show only busy (opaque) events");
   cmd.option("--free", "Show only free (transparent) events");
   cmd.option("--confirmed", "Show only confirmed events");
-  cmd.option("--include-tentative", "Include tentative events");
+  cmd.option("--include-tentative", "Include tentative events (excluded by default)");
+  const busyOpt = cmd.options.find((o) => o.long === "--busy");
+  const freeOpt = cmd.options.find((o) => o.long === "--free");
+  busyOpt.conflicts(["free"]);
+  freeOpt.conflicts(["busy"]);
   return cmd;
 }
 
 // src/commands/show.ts
 async function handleShow(opts) {
-  const { api: api2, eventId, calendarId, calendarName, format: format4, timezone, write } = opts;
-  try {
-    const event = await getEvent(api2, calendarId, calendarName, eventId, timezone);
-    if (format4 === "json") {
-      write(formatJsonSuccess({ event }));
-    } else {
-      write(formatEventDetailText(event));
-    }
-    return { exitCode: ExitCode.SUCCESS };
-  } catch (error) {
-    if (error instanceof ApiError) {
-      if (format4 === "json") {
-        write(formatJsonError(error.code, error.message));
-      } else {
-        write(`Error: ${error.message}`);
-      }
-      return { exitCode: errorCodeToExitCode(error.code) };
-    }
-    throw error;
+  const { api: api2, eventId, calendarId, calendarName, format: format4, quiet, timezone, write } = opts;
+  const event = await getEvent(api2, calendarId, calendarName, eventId, timezone);
+  if (format4 === "json") {
+    write(formatJsonSuccess({ event }));
+  } else if (quiet) {
+    write(`${event.title}	${event.start}	${event.end}`);
+  } else {
+    write(formatEventDetailText(event));
   }
+  return { exitCode: ExitCode.SUCCESS };
 }
 function createShowCommand() {
   return new Command("show").description("Show event details").argument("<event-id>", "Event ID").option("-c, --calendar <id>", "Calendar ID to query");
@@ -591778,24 +591844,6 @@ function resolveDateRange(input, timezone, now = () => new Date) {
     timeMax: formatDateTimeInZone(end, timezone)
   };
 }
-function formatQuietText(events) {
-  if (events.length === 0)
-    return "No events found.";
-  const lines = [];
-  for (const event of events) {
-    const month = event.start.slice(5, 7);
-    const day = event.start.slice(8, 10);
-    const datePrefix = `${month}/${day}`;
-    if (event.all_day) {
-      lines.push(`${datePrefix} All day      ${event.title}`);
-    } else {
-      const time3 = formatTimeRange(event);
-      lines.push(`${datePrefix} ${time3}  ${event.title}`);
-    }
-  }
-  return lines.join(`
-`);
-}
 async function handleList(options, deps) {
   const config2 = deps.loadConfig();
   const timezone = resolveTimezone(options.timezone, config2.timezone);
@@ -591813,7 +591861,7 @@ async function handleList(options, deps) {
   if (dateRange.warning && deps.writeErr) {
     deps.writeErr(dateRange.warning);
   }
-  const calendars = selectCalendars(options.calendar, config2);
+  const calendars = selectCalendars(options.calendar && options.calendar.length > 0 ? options.calendar : undefined, config2);
   const apiOptions = {
     timeMin: dateRange.timeMin,
     timeMax: dateRange.timeMax
@@ -591852,6 +591900,7 @@ async function handleList(options, deps) {
 }
 function createListCommand() {
   const cmd = new Command("list").description("List events within a date range");
+  cmd.option("-c, --calendar <id>", "Target calendar ID (repeatable)", collect, []);
   cmd.option("--today", "Show today's events");
   cmd.option("--days <n>", "Events for next n days (default: 7)", (v) => Number.parseInt(v, 10));
   cmd.option("--from <date>", "Start date (ISO 8601 or YYYY-MM-DD)");
@@ -591865,18 +591914,204 @@ function createListCommand() {
   const fromOpt = cmd.options.find((o) => o.long === "--from");
   const busyOpt = cmd.options.find((o) => o.long === "--busy");
   const freeOpt = cmd.options.find((o) => o.long === "--free");
+  const toOpt = cmd.options.find((o) => o.long === "--to");
   todayOpt.conflicts(["days", "from"]);
-  daysOpt.conflicts(["today", "from"]);
+  daysOpt.conflicts(["today", "from", "to"]);
   fromOpt.conflicts(["today", "days"]);
+  toOpt.conflicts(["days"]);
   busyOpt.conflicts(["free"]);
   freeOpt.conflicts(["busy"]);
   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: format4, timezone, write } = opts;
-  const hasUpdate = opts.title !== undefined || opts.start !== undefined || opts.end !== undefined || opts.description !== undefined || opts.busy !== undefined || opts.free !== undefined;
+  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");
   }
@@ -591892,19 +592127,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 = {};
@@ -591919,6 +592156,8 @@ async function handleUpdate(opts) {
       changes.start = withTime.start;
     if (withTime.end !== undefined)
       changes.end = withTime.end;
+    if (withTime.allDay !== undefined)
+      changes.allDay = withTime.allDay;
     if (format4 === "json") {
       write(formatJsonSuccess({
         dry_run: true,
@@ -591945,9 +592184,14 @@ async function handleUpdate(opts) {
   }
   const updated = await updateEvent(api2, calendarId, calendarName, eventId, input);
   if (format4 === "json") {
-    write(formatJsonSuccess({ event: updated }));
+    write(formatJsonSuccess({ event: updated, message: "Event updated" }));
+  } else if (opts.quiet) {
+    write(updated.id);
   } else {
-    write(formatEventDetailText(updated));
+    const detail = formatEventDetailText(updated);
+    write(`Event updated
+
+${detail}`);
   }
   return { exitCode: ExitCode.SUCCESS };
 }
@@ -591955,51 +592199,37 @@ 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;
 }
 
-// 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/add.ts
 async function handleAdd(options, deps) {
   if (!options.title) {
@@ -592045,12 +592275,12 @@ async function handleAdd(options, deps) {
         deps.write(formatJsonError("INVALID_ARGS", `Invalid duration: "${options.duration}". Use formats like 30m, 1h, 2d, 1h30m.`));
         return { exitCode: ExitCode.ARGUMENT };
       }
-      const MS_PER_DAY = 24 * 60 * 60 * 1000;
-      if (durationMs % MS_PER_DAY !== 0) {
+      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_DAY;
+      const days = durationMs / MS_PER_DAY2;
       end = addDaysToDateString(options.start, days);
     } else {
       end = addDaysToDateString(options.start, 1);
@@ -592087,9 +592317,37 @@ async function handleAdd(options, deps) {
   if (options.description !== undefined) {
     input.description = options.description;
   }
+  if (options.dryRun) {
+    const preview = {
+      title: input.title,
+      start: input.start,
+      end: input.end
+    };
+    if (input.description !== undefined)
+      preview.description = input.description;
+    if (input.transparency !== "opaque")
+      preview.transparency = input.transparency;
+    if (options.format === "json") {
+      deps.write(formatJsonSuccess({ dry_run: true, action: "add", event: preview }));
+    } else {
+      const lines = ["DRY RUN: Would create event:"];
+      lines.push(`  title: "${preview.title}"`);
+      lines.push(`  start: "${preview.start}"`);
+      lines.push(`  end: "${preview.end}"`);
+      if (preview.description !== undefined)
+        lines.push(`  description: "${preview.description}"`);
+      if (preview.transparency !== undefined)
+        lines.push(`  transparency: ${preview.transparency}`);
+      deps.write(lines.join(`
+`));
+    }
+    return { exitCode: ExitCode.SUCCESS };
+  }
   const event = await deps.createEvent(calendarId, calendarName, input);
   if (options.format === "json") {
     deps.write(formatJsonSuccess({ event, message: "Event created" }));
+  } else if (options.quiet) {
+    deps.write(event.id);
   } else {
     const detail = formatEventDetailText(event);
     deps.write(`Event created
@@ -592104,9 +592362,11 @@ function createAddCommand() {
   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("-c, --calendar <id>", "Target calendar ID");
   cmd.option("-d, --description <text>", "Event description");
   cmd.option("--busy", "Mark as busy (default)");
   cmd.option("--free", "Mark as free (transparent)");
+  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"]);
@@ -592132,8 +592392,7 @@ Examples:
 async function handleDelete(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 };
+    throw new ApiError("INVALID_ARGS", "event-id is required");
   }
   if (dryRun) {
     if (format4 === "json") {
@@ -592148,27 +592407,15 @@ async function handleDelete(opts) {
     }
     return { exitCode: ExitCode.SUCCESS };
   }
-  try {
-    await deleteEvent(api2, calendarId, eventId);
-    if (!quiet) {
-      if (format4 === "json") {
-        write(formatJsonSuccess({ deleted_id: eventId, message: "Event deleted" }));
-      } else {
-        write("Event deleted");
-      }
-    }
-    return { exitCode: ExitCode.SUCCESS };
-  } catch (error) {
-    if (error instanceof ApiError) {
-      if (format4 === "json") {
-        write(formatJsonError(error.code, error.message));
-      } else {
-        write(`Error: ${error.message}`);
-      }
-      return { exitCode: errorCodeToExitCode(error.code) };
+  await deleteEvent(api2, calendarId, eventId);
+  if (!quiet) {
+    if (format4 === "json") {
+      write(formatJsonSuccess({ deleted_id: eventId, message: "Event deleted" }));
+    } else {
+      write("Event deleted");
     }
-    throw error;
   }
+  return { exitCode: ExitCode.SUCCESS };
 }
 function createDeleteCommand() {
   return new Command("delete").description("Delete a calendar event").argument("<event-id>", "Event ID").option("-c, --calendar <id>", "Calendar ID to query").option("--dry-run", "Preview without executing");
@@ -592187,20 +592434,7 @@ function mergeCalendarsWithConfig(apiCalendars, configCalendars) {
 }
 async function handleCalendars(opts) {
   const { api: api2, format: format4, quiet, write, configCalendars } = opts;
-  let apiCalendars;
-  try {
-    apiCalendars = await listCalendars(api2);
-  } catch (error) {
-    if (error instanceof ApiError) {
-      if (format4 === "json") {
-        write(formatJsonError(error.code, error.message));
-      } else {
-        write(error.message);
-      }
-      return { exitCode: errorCodeToExitCode(error.code) };
-    }
-    throw error;
-  }
+  const apiCalendars = await listCalendars(api2);
   const calendars = mergeCalendarsWithConfig(apiCalendars, configCalendars);
   if (quiet) {
     write(calendars.map((c) => c.id).join(`
@@ -592312,58 +592546,6 @@ function createInitCommand() {
   return cmd;
 }
 
-// src/commands/shared.ts
-import * as nodeFs from "node:fs";
-var fsAdapter = {
-  existsSync: (p) => nodeFs.existsSync(p),
-  readFileSync: (p) => nodeFs.readFileSync(p, "utf-8"),
-  writeFileSync: (p, d) => nodeFs.writeFileSync(p, d, "utf-8"),
-  mkdirSync: (p) => nodeFs.mkdirSync(p, { recursive: true }),
-  unlinkSync: (p) => nodeFs.unlinkSync(p),
-  chmodSync: (p, m) => nodeFs.chmodSync(p, m)
-};
-function createGoogleCalendarApi(calendar) {
-  return {
-    calendarList: {
-      list: async (p) => {
-        const res = await calendar.calendarList.list(p);
-        const data = {};
-        if (res.data.items)
-          data.items = res.data.items;
-        if (res.data.nextPageToken)
-          data.nextPageToken = res.data.nextPageToken;
-        return { data };
-      }
-    },
-    events: {
-      list: async (p) => {
-        const res = await calendar.events.list(p);
-        const data = {};
-        if (res.data.items)
-          data.items = res.data.items;
-        if (res.data.nextPageToken)
-          data.nextPageToken = res.data.nextPageToken;
-        return { data };
-      },
-      get: async (p) => {
-        const res = await calendar.events.get(p);
-        return { data: res.data };
-      },
-      insert: async (p) => {
-        const res = await calendar.events.insert(p);
-        return { data: res.data };
-      },
-      patch: async (p) => {
-        const res = await calendar.events.patch(p);
-        return { data: res.data };
-      },
-      delete: async (p) => {
-        await calendar.events.delete(p);
-      }
-    }
-  };
-}
-
 // src/cli.ts
 var FormatSchema2 = _enum(["text", "json"]);
 function resolveGlobalOptions2(program2) {
@@ -592376,7 +592558,6 @@ function resolveGlobalOptions2(program2) {
   }
   return {
     format: formatResult.data,
-    calendar: raw.calendar,
     timezone: raw.timezone,
     quiet: raw.quiet
   };
@@ -592489,19 +592670,23 @@ ${url}`);
   const calendarsCmd = createCalendarsCommand();
   calendarsCmd.action(async () => {
     const globalOpts = resolveGlobalOptions2(program2);
-    const config2 = loadConfig(fsAdapter);
-    const oauth2Client = await getAuthenticatedClient(fsAdapter);
-    const calendar = import_googleapis2.google.calendar({ version: "v3", auth: oauth2Client });
-    const api2 = createGoogleCalendarApi(calendar);
-    const result = await handleCalendars({
-      api: api2,
-      format: globalOpts.format,
-      quiet: globalOpts.quiet,
-      write: (msg) => process.stdout.write(msg + `
+    try {
+      const config2 = loadConfig(fsAdapter);
+      const oauth2Client = await getAuthenticatedClient(fsAdapter);
+      const calendar = import_googleapis2.google.calendar({ version: "v3", auth: oauth2Client });
+      const api2 = createGoogleCalendarApi(calendar);
+      const result = await handleCalendars({
+        api: api2,
+        format: globalOpts.format,
+        quiet: globalOpts.quiet,
+        write: (msg) => process.stdout.write(msg + `
 `),
-      configCalendars: config2.calendars
-    });
-    process.exit(result.exitCode);
+        configCalendars: config2.calendars
+      });
+      process.exit(result.exitCode);
+    } catch (error) {
+      handleError2(error, globalOpts.format);
+    }
   });
   program2.addCommand(calendarsCmd);
   const listCmd = createListCommand();
@@ -592510,7 +592695,7 @@ ${url}`);
     const listOpts = listCmd.opts();
     try {
       const auth = await getAuthenticatedClient(fsAdapter);
-      const api2 = import_googleapis2.google.calendar({ version: "v3", auth });
+      const api2 = createGoogleCalendarApi(import_googleapis2.google.calendar({ version: "v3", auth }));
       const deps = {
         listEvents: (calendarId, calendarName, options) => listEvents(api2, calendarId, calendarName, options),
         loadConfig: () => loadConfig(fsAdapter),
@@ -592522,8 +592707,7 @@ ${url}`);
       const handleOpts = {
         ...listOpts,
         format: globalOpts.format,
-        quiet: globalOpts.quiet,
-        calendar: globalOpts.calendar
+        quiet: globalOpts.quiet
       };
       if (globalOpts.timezone)
         handleOpts.timezone = globalOpts.timezone;
@@ -592544,11 +592728,12 @@ ${url}`);
       const calendarApi = import_googleapis2.google.calendar({ version: "v3", auth });
       const api2 = createGoogleCalendarApi(calendarApi);
       const timezone = resolveTimezone(globalOpts.timezone, config2.timezone);
-      const calendars = selectCalendars(globalOpts.calendar, config2);
+      const calendars = selectCalendars(searchOpts.calendar.length > 0 ? searchOpts.calendar : undefined, config2);
       const result = await handleSearch({
         api: api2,
         query,
         format: globalOpts.format,
+        quiet: globalOpts.quiet,
         calendars,
         timezone,
         days: searchOpts.days,
@@ -592570,7 +592755,7 @@ ${url}`);
   });
   program2.addCommand(searchCmd);
   const showCmd = createShowCommand();
-  showCmd.action(async () => {
+  showCmd.action(async (eventId) => {
     const globalOpts = resolveGlobalOptions2(program2);
     const showOpts = showCmd.opts();
     try {
@@ -592578,23 +592763,24 @@ ${url}`);
       const auth = await getAuthenticatedClient(fsAdapter);
       const calendarApi = import_googleapis2.google.calendar({ version: "v3", auth });
       const api2 = createGoogleCalendarApi(calendarApi);
-      const calendarId = showOpts.calendar ?? (globalOpts.calendar.length > 0 ? globalOpts.calendar[0] : undefined);
+      const calendarId = showOpts.calendar;
       let cal;
       if (calendarId) {
         const found = config2.calendars.find((c) => c.id === calendarId);
         cal = found ? { id: found.id, name: found.name } : { id: calendarId, name: calendarId };
       } else {
         const calendars = selectCalendars(undefined, config2);
-        const resolved = await resolveEventCalendar(api2, showCmd.args[0], calendars);
+        const resolved = await resolveEventCalendar(api2, eventId, calendars);
         cal = resolved;
       }
       const timezone = resolveTimezone(globalOpts.timezone, config2.timezone);
       const result = await handleShow({
         api: api2,
-        eventId: showCmd.args[0],
+        eventId,
         calendarId: cal.id,
         calendarName: cal.name,
         format: globalOpts.format,
+        quiet: globalOpts.quiet,
         timezone,
         write: (msg) => process.stdout.write(msg + `
 `)
@@ -592615,8 +592801,8 @@ ${url}`);
       const calendarApi = import_googleapis2.google.calendar({ version: "v3", auth });
       const api2 = createGoogleCalendarApi(calendarApi);
       let resolvedCalendarId;
-      if (deleteOpts.calendar || globalOpts.calendar.length > 0) {
-        const calendars = selectCalendars(deleteOpts.calendar ? [deleteOpts.calendar] : globalOpts.calendar, config2);
+      if (deleteOpts.calendar) {
+        const calendars = selectCalendars([deleteOpts.calendar], config2);
         resolvedCalendarId = calendars[0]?.id ?? "primary";
       } else {
         const calendars = selectCalendars(undefined, config2);
@@ -592660,10 +592846,12 @@ ${url}`);
         description: addOpts.description,
         busy: addOpts.busy,
         free: addOpts.free,
+        dryRun: addOpts.dryRun,
+        quiet: globalOpts.quiet,
         format: globalOpts.format
       };
-      if (globalOpts.calendar?.[0])
-        handleOpts.calendar = globalOpts.calendar[0];
+      if (addOpts.calendar)
+        handleOpts.calendar = addOpts.calendar;
       if (globalOpts.timezone)
         handleOpts.timezone = globalOpts.timezone;
       const result = await handleAdd(handleOpts, deps);
@@ -592736,8 +592924,8 @@ ${authUrl}`);
       const timezone = resolveTimezone(globalOpts.timezone, config2.timezone);
       const updateOpsCalendar = updateOpts.calendar;
       let cal;
-      if (updateOpsCalendar || globalOpts.calendar.length > 0) {
-        const calendars = selectCalendars(updateOpsCalendar ? [updateOpsCalendar] : globalOpts.calendar, config2);
+      if (updateOpsCalendar) {
+        const calendars = selectCalendars([updateOpsCalendar], config2);
         cal = calendars[0];
       } else {
         const calendars = selectCalendars(undefined, config2);
@@ -592750,9 +592938,13 @@ ${authUrl}`);
         calendarId: cal.id,
         calendarName: cal.name,
         format: globalOpts.format,
+        quiet: globalOpts.quiet,
         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.3",
+  "version": "0.4.0",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"