@ncukondo/gcal-cli 0.3.0 → 0.5.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.3.0",
+  version: "0.5.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
   };
@@ -588008,6 +588022,7 @@ async function getAuthenticatedClient(fs, fetchFn = globalThis.fetch) {
 var OAUTH_SCOPES = [
   "https://www.googleapis.com/auth/calendar.readonly",
   "https://www.googleapis.com/auth/calendar.events",
+  "https://www.googleapis.com/auth/tasks",
   "email"
 ];
 async function startOAuthFlow(credentials, fs, fetchFn = globalThis.fetch) {
@@ -588207,6 +588222,24 @@ function createAuthCommand() {
   return cmd;
 }
 
+// src/lib/api-utils.ts
+var MAX_PAGES = 100;
+function isGoogleApiError(error) {
+  return error instanceof Error && "code" in error && typeof error.code === "number";
+}
+function mapApiError(error) {
+  if (isGoogleApiError(error)) {
+    if (error.code === 401 || error.code === 403) {
+      throw new ApiError("AUTH_REQUIRED", error.message);
+    }
+    if (error.code === 404) {
+      throw new ApiError("NOT_FOUND", error.message);
+    }
+    throw new ApiError("API_ERROR", error.message);
+  }
+  throw error;
+}
+
 // src/lib/api.ts
 class ApiError extends Error {
   code;
@@ -588216,7 +588249,6 @@ class ApiError extends Error {
     this.name = "ApiError";
   }
 }
-var MAX_PAGES = 100;
 var EventStatusSchema = _enum(["confirmed", "tentative", "cancelled"]).catch("confirmed");
 var TransparencySchema = _enum(["opaque", "transparent"]).catch("opaque");
 function normalizeEvent(event, calendarId, calendarName) {
@@ -588380,24 +588412,9 @@ async function deleteEvent(api2, calendarId, eventId) {
     mapApiError(error);
   }
 }
-function isGoogleApiError(error) {
-  return error instanceof Error && "code" in error && typeof error.code === "number";
-}
 function isAuthRequiredError(error) {
   return (error instanceof ApiError || error instanceof AuthError) && (error.code === "AUTH_REQUIRED" || error.code === "AUTH_EXPIRED");
 }
-function mapApiError(error) {
-  if (isGoogleApiError(error)) {
-    if (error.code === 401 || error.code === 403) {
-      throw new ApiError("AUTH_REQUIRED", error.message);
-    }
-    if (error.code === 404) {
-      throw new ApiError("NOT_FOUND", error.message);
-    }
-    throw new ApiError("API_ERROR", error.message);
-  }
-  throw error;
-}
 
 // src/lib/filter.ts
 function filterByTransparency(events, option) {
@@ -588424,6 +588441,102 @@ 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 createGoogleTasksClient(tasks) {
+  return {
+    tasklists: {
+      list: async (p) => {
+        const res = await tasks.tasklists.list(p);
+        const data = {};
+        if (res.data.items)
+          data.items = res.data.items;
+        if (res.data.nextPageToken)
+          data.nextPageToken = res.data.nextPageToken;
+        return { data };
+      }
+    },
+    tasks: {
+      list: async (p) => {
+        const res = await tasks.tasks.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 tasks.tasks.get(p);
+        return { data: res.data };
+      },
+      insert: async (p) => {
+        const res = await tasks.tasks.insert(p);
+        return { data: res.data };
+      },
+      patch: async (p) => {
+        const res = await tasks.tasks.patch(p);
+        return { data: res.data };
+      },
+      delete: async (p) => {
+        await tasks.tasks.delete(p);
+      }
+    }
+  };
+}
+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 +590709,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 +590718,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 +590726,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 +590740,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 +590761,8 @@ async function handleSearch(opts) {
       events: filtered,
       count: filtered.length
     }));
+  } else if (quiet) {
+    write(formatQuietText(filtered));
   } else {
     write(formatSearchResultText(query, filtered));
   }
@@ -590655,9 +590770,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 +590783,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");
@@ -590829,11 +590939,16 @@ function skipComment(str, ptr) {
 }
 function skipVoid(str, ptr, banNewLines, banComments) {
   let c;
-  while ((c = str[ptr]) === " " || c === "\t" || !banNewLines && (c === `
+  while (true) {
+    while ((c = str[ptr]) === " " || c === "\t" || !banNewLines && (c === `
 ` || c === "\r" && str[ptr + 1] === `
 `))
-    ptr++;
-  return banComments || c !== "#" ? ptr : skipVoid(str, skipComment(str, ptr), banNewLines);
+      ptr++;
+    if (banComments || c !== "#")
+      break;
+    ptr = skipComment(str, ptr);
+  }
+  return ptr;
 }
 function skipUntil(str, ptr, sep, end, banNewLines = false) {
   if (!end) {
@@ -591665,6 +591780,11 @@ function parseConfig(toml) {
     name: String(c["name"]),
     enabled: Boolean(c["enabled"])
   })) : [];
+  const task_lists = Array.isArray(raw["task_lists"]) ? raw["task_lists"].map((t) => ({
+    id: String(t["id"]),
+    name: String(t["name"]),
+    enabled: Boolean(t["enabled"])
+  })) : [];
   const envFormat = process.env["GCAL_CLI_FORMAT"];
   const envTimezone = process.env["GCAL_CLI_TIMEZONE"];
   const fileFormat = typeof raw["default_format"] === "string" ? validateOutputFormat(raw["default_format"], "config file") : "text";
@@ -591672,7 +591792,8 @@ function parseConfig(toml) {
   const timezone = envTimezone || fileTimezone;
   const config2 = {
     default_format: envFormat ? validateOutputFormat(envFormat, "GCAL_CLI_FORMAT env var") : fileFormat,
-    calendars
+    calendars,
+    task_lists
   };
   if (timezone) {
     config2.timezone = timezone;
@@ -591708,7 +591829,7 @@ function getDefaultConfigPath() {
 function escapeTomlString(value) {
   return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
 }
-function generateConfigToml(calendars, timezone) {
+function generateConfigToml(calendars, timezone, taskLists) {
   const lines = [];
   if (timezone) {
     lines.push(`timezone = "${escapeTomlString(timezone)}"`);
@@ -591721,6 +591842,15 @@ function generateConfigToml(calendars, timezone) {
     lines.push(`enabled = ${String(cal.enabled)}`);
     lines.push("");
   }
+  if (taskLists && taskLists.length > 0) {
+    for (const tl of taskLists) {
+      lines.push("[[task_lists]]");
+      lines.push(`id = "${escapeTomlString(tl.id)}"`);
+      lines.push(`name = "${escapeTomlString(tl.name)}"`);
+      lines.push(`enabled = ${String(tl.enabled)}`);
+      lines.push("");
+    }
+  }
   return lines.join(`
 `);
 }
@@ -591778,24 +591908,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 +591925,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 +591964,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,9 +591978,11 @@ 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;
@@ -592133,9 +592248,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 };
 }
@@ -592261,9 +592381,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
@@ -592278,9 +592426,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"]);
@@ -592306,8 +592456,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") {
@@ -592322,27 +592471,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");
@@ -592361,20 +592498,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(`
@@ -592399,6 +592523,7 @@ function resolveTimezone2(cliTimezone) {
 }
 async function handleInit(opts) {
   const { fs, format: format4, quiet, write, force, all, local, requestAuth } = opts;
+  const writeErr = quiet ? () => {} : opts.writeErr ?? (() => {});
   const configPath = local ? `${process.cwd()}/gcal-cli.toml` : getDefaultConfigPath();
   if (!force && fs.existsSync(configPath)) {
     const msg = `Config file already exists: ${configPath}
@@ -592443,18 +592568,32 @@ Use --force to overwrite.`;
     name: cal.name,
     enabled: all || cal.primary
   }));
+  let configTaskLists = [];
+  if (opts.listTaskLists) {
+    try {
+      const taskLists = await opts.listTaskLists();
+      configTaskLists = taskLists.map((tl) => ({
+        id: tl.id,
+        name: tl.title,
+        enabled: all || tl.id === "@default"
+      }));
+    } catch {
+      writeErr("[init] Tasks API unavailable, skipping task lists");
+    }
+  }
   const timezone = resolveTimezone2(opts.timezone);
-  const toml = generateConfigToml(configCalendars, timezone);
+  const toml = generateConfigToml(configCalendars, timezone, configTaskLists.length > 0 ? configTaskLists : undefined);
   const dir = path.dirname(configPath);
   fs.mkdirSync(dir, { recursive: true });
   fs.writeFileSync(configPath, toml);
   const enabledCalendars = configCalendars.filter((c) => c.enabled);
+  const enabledTaskLists = configTaskLists.filter((t) => t.enabled);
   if (quiet) {
     write(configPath);
     return { exitCode: ExitCode.SUCCESS };
   }
   if (format4 === "json") {
-    write(formatJsonSuccess({
+    const data = {
       path: configPath,
       timezone,
       calendars: configCalendars.map((c) => ({
@@ -592464,7 +592603,15 @@ Use --force to overwrite.`;
       })),
       enabled_count: enabledCalendars.length,
       total_count: configCalendars.length
-    }));
+    };
+    if (configTaskLists.length > 0) {
+      data.task_lists = configTaskLists.map((t) => ({
+        id: t.id,
+        name: t.name,
+        enabled: t.enabled
+      }));
+    }
+    write(formatJsonSuccess(data));
   } else {
     write(`Config file created: ${configPath}`);
     write("");
@@ -592472,6 +592619,13 @@ Use --force to overwrite.`;
     for (const cal of enabledCalendars) {
       write(`  - ${cal.name} (${cal.id})`);
     }
+    if (enabledTaskLists.length > 0) {
+      write("");
+      write("Enabled task lists:");
+      for (const tl of enabledTaskLists) {
+        write(`  - ${tl.name} (${tl.id})`);
+      }
+    }
     write("");
     write(`Timezone: ${timezone}`);
   }
@@ -592486,56 +592640,551 @@ 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) {
+// src/commands/tasks/index.ts
+function createTasksCommand() {
+  const tasksCmd = new Command("tasks").description("Manage Google Tasks");
+  const listsCmd = new Command("lists").description("List task lists");
+  tasksCmd.addCommand(listsCmd);
+  const listCmd = new Command("list").description("List tasks").option("-l, --list <name-or-id>", "Task list name or ID").option("--all", "Include completed tasks").option("--completed", "Show only completed tasks").option("--due-before <date>", "Tasks due before date (YYYY-MM-DD)").option("--due-after <date>", "Tasks due after date (YYYY-MM-DD)");
+  tasksCmd.addCommand(listCmd);
+  const showCmd = new Command("show").description("Show task details").argument("<task-id>", "Task ID").option("-l, --list <name-or-id>", "Task list name or ID");
+  tasksCmd.addCommand(showCmd);
+  const addCmd = new Command("add").description("Create a new task").requiredOption("-t, --title <title>", "Task title").option("-n, --notes <text>", "Notes").option("--due <date>", "Due date (YYYY-MM-DD)").option("-l, --list <name-or-id>", "Task list name or ID").option("--parent <task-id>", "Parent task ID (create as subtask)");
+  tasksCmd.addCommand(addCmd);
+  const updateCmd = new Command("update").description("Update an existing task").argument("<task-id>", "Task ID to update").option("-t, --title <title>", "New title").option("-n, --notes <text>", "New notes").option("--due <date>", "New due date (YYYY-MM-DD)").option("-l, --list <name-or-id>", "Task list name or ID");
+  tasksCmd.addCommand(updateCmd);
+  const doneCmd = new Command("done").description("Mark a task as completed").argument("<task-id>", "Task ID to complete").option("-l, --list <name-or-id>", "Task list name or ID");
+  tasksCmd.addCommand(doneCmd);
+  const undoneCmd = new Command("undone").description("Mark a task as not completed").argument("<task-id>", "Task ID to reopen").option("-l, --list <name-or-id>", "Task list name or ID");
+  tasksCmd.addCommand(undoneCmd);
+  const deleteCmd = new Command("delete").description("Delete a task").argument("<task-id>", "Task ID to delete").option("-l, --list <name-or-id>", "Task list name or ID");
+  tasksCmd.addCommand(deleteCmd);
+  return { tasksCmd, listsCmd, listCmd, showCmd, addCmd, updateCmd, doneCmd, undoneCmd, deleteCmd };
+}
+
+// src/lib/tasks-api.ts
+function normalizeTaskList(raw) {
   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 };
+    id: raw.id ?? "",
+    title: raw.title ?? "",
+    updated: raw.updated ?? ""
+  };
+}
+var VALID_TASK_STATUSES = ["needsAction", "completed"];
+function parseTaskStatus(value) {
+  if (value && VALID_TASK_STATUSES.includes(value)) {
+    return value;
+  }
+  return "needsAction";
+}
+function parseDueDate(due) {
+  if (!due)
+    return null;
+  return due.slice(0, 10);
+}
+function normalizeTask(raw, listId, listTitle) {
+  return {
+    id: raw.id ?? "",
+    title: raw.title ?? "",
+    notes: raw.notes ?? null,
+    status: parseTaskStatus(raw.status),
+    due: parseDueDate(raw.due),
+    completed: raw.completed ?? null,
+    list_id: listId,
+    list_title: listTitle,
+    parent: raw.parent ?? null,
+    updated: raw.updated ?? ""
+  };
+}
+async function listTaskLists(client) {
+  try {
+    const results = [];
+    let pageToken;
+    let pages = 0;
+    do {
+      if (pages >= MAX_PAGES) {
+        throw new ApiError("API_ERROR", `Pagination limit of ${MAX_PAGES} pages exceeded`);
       }
-    },
-    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);
+      const response = await client.tasklists.list(pageToken ? { pageToken } : undefined);
+      const items = response.data.items ?? [];
+      for (const item of items) {
+        results.push(normalizeTaskList(item));
       }
+      pageToken = response.data.nextPageToken;
+      pages++;
+    } while (pageToken);
+    return results;
+  } catch (error) {
+    mapApiError(error);
+  }
+}
+async function listTasks(client, taskListId, listTitle, options) {
+  try {
+    const results = [];
+    let pageToken;
+    let pages = 0;
+    do {
+      if (pages >= MAX_PAGES) {
+        throw new ApiError("API_ERROR", `Pagination limit of ${MAX_PAGES} pages exceeded`);
+      }
+      const params = {
+        tasklist: taskListId,
+        ...options
+      };
+      if (pageToken) {
+        params.pageToken = pageToken;
+      }
+      const response = await client.tasks.list(params);
+      const items = response.data.items ?? [];
+      for (const item of items) {
+        results.push(normalizeTask(item, taskListId, listTitle));
+      }
+      pageToken = response.data.nextPageToken;
+      pages++;
+    } while (pageToken);
+    return results;
+  } catch (error) {
+    mapApiError(error);
+  }
+}
+async function getTask(client, taskListId, listTitle, taskId) {
+  try {
+    const response = await client.tasks.get({ tasklist: taskListId, task: taskId });
+    return normalizeTask(response.data, taskListId, listTitle);
+  } catch (error) {
+    mapApiError(error);
+  }
+}
+async function createTask(client, taskListId, listTitle, input) {
+  try {
+    const requestBody = {
+      title: input.title
+    };
+    if (input.notes !== undefined) {
+      requestBody.notes = input.notes;
+    }
+    if (input.due !== undefined) {
+      requestBody.due = input.due;
+    }
+    const params = { tasklist: taskListId, requestBody };
+    if (input.parent !== undefined) {
+      params.parent = input.parent;
+    }
+    const response = await client.tasks.insert(params);
+    return normalizeTask(response.data, taskListId, listTitle);
+  } catch (error) {
+    mapApiError(error);
+  }
+}
+async function updateTask(client, taskListId, listTitle, taskId, input) {
+  try {
+    const requestBody = {};
+    if (input.title !== undefined) {
+      requestBody.title = input.title;
+    }
+    if (input.notes !== undefined) {
+      requestBody.notes = input.notes;
+    }
+    if (input.due !== undefined) {
+      requestBody.due = input.due;
     }
+    const response = await client.tasks.patch({
+      tasklist: taskListId,
+      task: taskId,
+      requestBody
+    });
+    return normalizeTask(response.data, taskListId, listTitle);
+  } catch (error) {
+    mapApiError(error);
+  }
+}
+async function deleteTask(client, taskListId, taskId) {
+  try {
+    await client.tasks.delete({ tasklist: taskListId, task: taskId });
+  } catch (error) {
+    mapApiError(error);
+  }
+}
+async function completeTask(client, taskListId, listTitle, taskId) {
+  try {
+    const response = await client.tasks.patch({
+      tasklist: taskListId,
+      task: taskId,
+      requestBody: { status: "completed" }
+    });
+    return normalizeTask(response.data, taskListId, listTitle);
+  } catch (error) {
+    mapApiError(error);
+  }
+}
+async function uncompleteTask(client, taskListId, listTitle, taskId) {
+  try {
+    const response = await client.tasks.patch({
+      tasklist: taskListId,
+      task: taskId,
+      requestBody: { status: "needsAction", completed: null }
+    });
+    return normalizeTask(response.data, taskListId, listTitle);
+  } catch (error) {
+    mapApiError(error);
+  }
+}
+
+// src/commands/tasks/lists.ts
+function mergeTaskListsWithConfig(apiLists, configLists) {
+  const hasConfig = configLists.length > 0;
+  const configMap = new Map(configLists.map((c) => [c.id, c]));
+  return apiLists.map((list) => {
+    const config2 = configMap.get(list.id);
+    return {
+      ...list,
+      enabled: hasConfig ? config2 ? config2.enabled : true : true
+    };
+  });
+}
+function formatTaskListText(lists) {
+  const lines = ["Task Lists:"];
+  for (const list of lists) {
+    const checkbox = list.enabled ? "[x]" : "[ ]";
+    const suffix = list.enabled ? "" : " (disabled)";
+    lines.push(`  ${checkbox} ${list.title} (${list.id})${suffix}`);
+  }
+  return lines.join(`
+`);
+}
+async function handleTaskLists(opts) {
+  const { client, format: format4, quiet, write, configTaskLists } = opts;
+  const apiLists = await listTaskLists(client);
+  const lists = mergeTaskListsWithConfig(apiLists, configTaskLists);
+  if (quiet) {
+    write(lists.map((l) => l.id).join(`
+`));
+    return { exitCode: ExitCode.SUCCESS };
+  }
+  if (format4 === "json") {
+    write(formatJsonSuccess({ task_lists: lists, count: lists.length }));
+  } else {
+    write(formatTaskListText(lists));
+  }
+  return { exitCode: ExitCode.SUCCESS };
+}
+
+// src/commands/tasks/resolve.ts
+function resolveTaskListFromConfig(configLists, listOption) {
+  if (!listOption) {
+    const enabled = configLists.find((c) => c.enabled);
+    if (enabled)
+      return { id: enabled.id, title: enabled.name };
+    return null;
+  }
+  const byName = configLists.find((c) => c.name === listOption);
+  if (byName)
+    return { id: byName.id, title: byName.name };
+  const byId = configLists.find((c) => c.id === listOption);
+  if (byId)
+    return { id: byId.id, title: byId.name };
+  return null;
+}
+async function resolveTaskList(client, configLists, listOption) {
+  const fromConfig = resolveTaskListFromConfig(configLists, listOption);
+  if (fromConfig)
+    return fromConfig;
+  if (listOption) {
+    const apiLists = await listTaskLists(client);
+    const byTitle = apiLists.find((l) => l.title === listOption);
+    if (byTitle)
+      return { id: byTitle.id, title: byTitle.title };
+    return { id: listOption, title: listOption };
+  }
+  return { id: "@default", title: "My Tasks" };
+}
+
+// src/commands/tasks/list.ts
+function isValidDateString(value) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
+    return false;
+  const date3 = new Date(`${value}T00:00:00Z`);
+  if (Number.isNaN(date3.getTime()))
+    return false;
+  return date3.toISOString().startsWith(value);
+}
+function formatDueInfo(task) {
+  const parts = [];
+  if (task.due) {
+    const month = task.due.slice(5, 7);
+    const day = task.due.slice(8, 10);
+    parts.push(`due: ${month}/${day}`);
+  }
+  if (task.status === "completed" && task.completed) {
+    const month = task.completed.slice(5, 7);
+    const day = task.completed.slice(8, 10);
+    parts.push(`completed: ${month}/${day}`);
+  }
+  return parts.length > 0 ? ` (${parts.join(", ")})` : "";
+}
+function formatTaskLine(task) {
+  const checkbox = task.status === "completed" ? "☑" : "□";
+  return `${checkbox} ${task.title}${formatDueInfo(task)}`;
+}
+function formatTaskListText2(listTitle, tasks) {
+  const lines = [`${listTitle}:`];
+  for (const task of tasks) {
+    lines.push(`  ${formatTaskLine(task)}`);
+    if (task.notes) {
+      const firstLine = task.notes.split(`
+`)[0];
+      lines.push(`    Notes: ${firstLine}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function formatQuietTaskList(tasks) {
+  return tasks.map((task) => formatTaskLine(task)).join(`
+`);
+}
+function filterTasks(tasks, options) {
+  let filtered = tasks;
+  if (options.completed) {
+    filtered = filtered.filter((t) => t.status === "completed");
+  } else if (!options.all) {
+    filtered = filtered.filter((t) => t.status === "needsAction");
+  }
+  if (options.dueBefore) {
+    filtered = filtered.filter((t) => t.due !== null && t.due <= options.dueBefore);
+  }
+  if (options.dueAfter) {
+    filtered = filtered.filter((t) => t.due !== null && t.due >= options.dueAfter);
+  }
+  return filtered;
+}
+async function handleTaskList(opts) {
+  const { client, format: format4, quiet, write, configTaskLists, all, completed, dueBefore, dueAfter } = opts;
+  if (dueBefore !== undefined && !isValidDateString(dueBefore)) {
+    write(`Error: Invalid date for --due-before: "${dueBefore}". Expected format: YYYY-MM-DD`);
+    return { exitCode: ExitCode.ARGUMENT };
+  }
+  if (dueAfter !== undefined && !isValidDateString(dueAfter)) {
+    write(`Error: Invalid date for --due-after: "${dueAfter}". Expected format: YYYY-MM-DD`);
+    return { exitCode: ExitCode.ARGUMENT };
+  }
+  const resolved = await resolveTaskList(client, configTaskLists, opts.list);
+  const apiOptions = {};
+  if (all || completed) {
+    apiOptions.showCompleted = true;
+    apiOptions.showHidden = true;
+  }
+  const allTasks = await listTasks(client, resolved.id, resolved.title, apiOptions);
+  const filterOpts = {
+    all: all ?? false,
+    completed: completed ?? false
   };
+  if (dueBefore !== undefined)
+    filterOpts.dueBefore = dueBefore;
+  if (dueAfter !== undefined)
+    filterOpts.dueAfter = dueAfter;
+  const tasks = filterTasks(allTasks, filterOpts);
+  if (quiet) {
+    write(formatQuietTaskList(tasks));
+    return { exitCode: ExitCode.SUCCESS };
+  }
+  if (format4 === "json") {
+    write(formatJsonSuccess({
+      tasks,
+      count: tasks.length,
+      list_id: resolved.id,
+      list_title: resolved.title
+    }));
+  } else {
+    write(formatTaskListText2(resolved.title, tasks));
+  }
+  return { exitCode: ExitCode.SUCCESS };
+}
+
+// src/commands/tasks/show.ts
+var LABEL_WIDTH = 11;
+function detailLine2(label, value) {
+  return `${label}:`.padEnd(LABEL_WIDTH) + value;
+}
+function stripMilliseconds(iso) {
+  return iso.replace(/\.\d{3}Z$/, "Z");
+}
+function formatTaskDetailText(task) {
+  const lines = [];
+  lines.push(detailLine2("ID", task.id));
+  lines.push(detailLine2("Title", task.title));
+  lines.push(detailLine2("Status", task.status));
+  if (task.due) {
+    lines.push(detailLine2("Due", task.due));
+  }
+  if (task.notes) {
+    lines.push(detailLine2("Notes", task.notes));
+  }
+  lines.push(detailLine2("List", task.list_title));
+  lines.push(detailLine2("Updated", stripMilliseconds(task.updated)));
+  return lines.join(`
+`);
+}
+async function handleTaskShow(opts) {
+  const { client, taskId, format: format4, quiet, write, configTaskLists } = opts;
+  const resolved = await resolveTaskList(client, configTaskLists, opts.list);
+  const task = await getTask(client, resolved.id, resolved.title, taskId);
+  if (format4 === "json") {
+    write(formatJsonSuccess({ task }));
+  } else if (quiet) {
+    write(`${task.title}	${task.status}	${task.due ?? ""}`);
+  } else {
+    write(formatTaskDetailText(task));
+  }
+  return { exitCode: ExitCode.SUCCESS };
+}
+
+// src/commands/tasks/add.ts
+function isValidDateString2(value) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
+    return false;
+  const date3 = new Date(`${value}T00:00:00Z`);
+  if (Number.isNaN(date3.getTime()))
+    return false;
+  return date3.toISOString().startsWith(value);
+}
+async function handleTaskAdd(opts) {
+  const { client, title, format: format4, quiet, write, configTaskLists } = opts;
+  if (!title) {
+    const msg = "--title is required";
+    if (format4 === "json") {
+      write(formatJsonError("INVALID_ARGS", msg));
+    } else {
+      write(`Error: ${msg}`);
+    }
+    return { exitCode: ExitCode.ARGUMENT };
+  }
+  if (opts.due !== undefined && !isValidDateString2(opts.due)) {
+    const msg = `Invalid date format: ${opts.due} (expected YYYY-MM-DD)`;
+    if (format4 === "json") {
+      write(formatJsonError("INVALID_ARGS", msg));
+    } else {
+      write(`Error: ${msg}`);
+    }
+    return { exitCode: ExitCode.ARGUMENT };
+  }
+  const resolved = await resolveTaskList(client, configTaskLists, opts.list);
+  const input = { title };
+  if (opts.notes !== undefined) {
+    input.notes = opts.notes;
+  }
+  if (opts.due !== undefined) {
+    input.due = `${opts.due}T00:00:00.000Z`;
+  }
+  if (opts.parent !== undefined) {
+    input.parent = opts.parent;
+  }
+  const task = await createTask(client, resolved.id, resolved.title, input);
+  if (format4 === "json") {
+    write(formatJsonSuccess({ task, message: "Task created" }));
+  } else if (quiet) {
+    write(task.id);
+  } else {
+    write(`Task created: ${task.title} (${task.id})`);
+  }
+  return { exitCode: ExitCode.SUCCESS };
+}
+
+// src/commands/tasks/update.ts
+function isValidDateString3(value) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
+    return false;
+  const date3 = new Date(`${value}T00:00:00Z`);
+  if (Number.isNaN(date3.getTime()))
+    return false;
+  return date3.toISOString().startsWith(value);
+}
+async function handleTaskUpdate(opts) {
+  const { client, taskId, format: format4, quiet, write, configTaskLists } = opts;
+  const hasUpdate = opts.title !== undefined || opts.notes !== undefined || opts.due !== undefined;
+  if (!hasUpdate) {
+    const msg = "at least one update option must be provided (--title, --notes, or --due)";
+    if (format4 === "json") {
+      write(formatJsonError("INVALID_ARGS", msg));
+    } else {
+      write(`Error: ${msg}`);
+    }
+    return { exitCode: ExitCode.ARGUMENT };
+  }
+  if (opts.due !== undefined && !isValidDateString3(opts.due)) {
+    const msg = `Invalid date format: ${opts.due} (expected YYYY-MM-DD)`;
+    if (format4 === "json") {
+      write(formatJsonError("INVALID_ARGS", msg));
+    } else {
+      write(`Error: ${msg}`);
+    }
+    return { exitCode: ExitCode.ARGUMENT };
+  }
+  const resolved = await resolveTaskList(client, configTaskLists, opts.list);
+  const input = {};
+  if (opts.title !== undefined) {
+    input.title = opts.title;
+  }
+  if (opts.notes !== undefined) {
+    input.notes = opts.notes;
+  }
+  if (opts.due !== undefined) {
+    input.due = `${opts.due}T00:00:00.000Z`;
+  }
+  const task = await updateTask(client, resolved.id, resolved.title, taskId, input);
+  if (format4 === "json") {
+    write(formatJsonSuccess({ task, message: "Task updated" }));
+  } else if (quiet) {
+    write(task.id);
+  } else {
+    write(`Task updated: ${task.title} (${task.id})`);
+  }
+  return { exitCode: ExitCode.SUCCESS };
+}
+
+// src/commands/tasks/done.ts
+async function handleTaskDone(opts) {
+  const { client, taskId, format: format4, quiet, write, configTaskLists } = opts;
+  const resolved = await resolveTaskList(client, configTaskLists, opts.list);
+  const task = await completeTask(client, resolved.id, resolved.title, taskId);
+  if (format4 === "json") {
+    write(formatJsonSuccess({ task, message: "Task completed" }));
+  } else if (quiet) {
+    write(task.id);
+  } else {
+    write(`Task completed: ${task.title} (${task.id})`);
+  }
+  return { exitCode: ExitCode.SUCCESS };
+}
+
+// src/commands/tasks/undone.ts
+async function handleTaskUndone(opts) {
+  const { client, taskId, format: format4, quiet, write, configTaskLists } = opts;
+  const resolved = await resolveTaskList(client, configTaskLists, opts.list);
+  const task = await uncompleteTask(client, resolved.id, resolved.title, taskId);
+  if (format4 === "json") {
+    write(formatJsonSuccess({ task, message: "Task reopened" }));
+  } else if (quiet) {
+    write(task.id);
+  } else {
+    write(`Task reopened: ${task.title} (${task.id})`);
+  }
+  return { exitCode: ExitCode.SUCCESS };
+}
+
+// src/commands/tasks/delete.ts
+async function handleTaskDelete(opts) {
+  const { client, taskId, format: format4, quiet, write, configTaskLists } = opts;
+  const resolved = await resolveTaskList(client, configTaskLists, opts.list);
+  await deleteTask(client, resolved.id, taskId);
+  if (!quiet) {
+    if (format4 === "json") {
+      write(formatJsonSuccess({ deleted_id: taskId, message: "Task deleted" }));
+    } else {
+      write(`Task deleted (${taskId})`);
+    }
+  }
+  return { exitCode: ExitCode.SUCCESS };
 }
 
 // src/cli.ts
@@ -592550,7 +593199,6 @@ function resolveGlobalOptions2(program2) {
   }
   return {
     format: formatResult.data,
-    calendar: raw.calendar,
     timezone: raw.timezone,
     quiet: raw.quiet
   };
@@ -592625,6 +593273,25 @@ async function resolveEventCalendar(api2, eventId, calendars) {
 }
 
 // src/commands/index.ts
+async function runTaskAction(program2, handler) {
+  const globalOpts = resolveGlobalOptions2(program2);
+  try {
+    const config2 = loadConfig(fsAdapter);
+    const oauth2Client = await getAuthenticatedClient(fsAdapter);
+    const client = createGoogleTasksClient(import_googleapis2.google.tasks({ version: "v1", auth: oauth2Client }));
+    const result = await handler({
+      client,
+      format: globalOpts.format,
+      quiet: globalOpts.quiet,
+      write: (msg) => process.stdout.write(msg + `
+`),
+      configTaskLists: config2.task_lists
+    });
+    process.exit(result.exitCode);
+  } catch (error) {
+    handleError2(error, globalOpts.format);
+  }
+}
 function registerCommands(program2) {
   const authCmd = createAuthCommand();
   authCmd.action(async () => {
@@ -592663,28 +593330,175 @@ ${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 {
+    tasksCmd,
+    listsCmd: tasksListsCmd,
+    listCmd: tasksListCmd,
+    showCmd: tasksShowCmd,
+    addCmd: tasksAddCmd,
+    updateCmd: tasksUpdateCmd,
+    doneCmd: tasksDoneCmd,
+    undoneCmd: tasksUndoneCmd,
+    deleteCmd: tasksDeleteCmd
+  } = createTasksCommand();
+  tasksListsCmd.action(async () => {
+    const globalOpts = resolveGlobalOptions2(program2);
+    try {
+      const config2 = loadConfig(fsAdapter);
+      const oauth2Client = await getAuthenticatedClient(fsAdapter);
+      const tasksClient = createGoogleTasksClient(import_googleapis2.google.tasks({ version: "v1", auth: oauth2Client }));
+      const result = await handleTaskLists({
+        client: tasksClient,
+        format: globalOpts.format,
+        quiet: globalOpts.quiet,
+        write: (msg) => process.stdout.write(msg + `
+`),
+        configTaskLists: config2.task_lists
+      });
+      process.exit(result.exitCode);
+    } catch (error) {
+      handleError2(error, globalOpts.format);
+    }
+  });
+  tasksListCmd.action(async () => {
+    const globalOpts = resolveGlobalOptions2(program2);
+    const listOpts = tasksListCmd.opts();
+    try {
+      const config2 = loadConfig(fsAdapter);
+      const oauth2Client = await getAuthenticatedClient(fsAdapter);
+      const tasksClient = createGoogleTasksClient(import_googleapis2.google.tasks({ version: "v1", auth: oauth2Client }));
+      const opts = {
+        client: tasksClient,
+        format: globalOpts.format,
+        quiet: globalOpts.quiet,
+        write: (msg) => process.stdout.write(msg + `
+`),
+        configTaskLists: config2.task_lists
+      };
+      if (listOpts.list !== undefined)
+        opts.list = listOpts.list;
+      if (listOpts.all)
+        opts.all = true;
+      if (listOpts.completed)
+        opts.completed = true;
+      if (listOpts.dueBefore !== undefined)
+        opts.dueBefore = listOpts.dueBefore;
+      if (listOpts.dueAfter !== undefined)
+        opts.dueAfter = listOpts.dueAfter;
+      const result = await handleTaskList(opts);
+      process.exit(result.exitCode);
+    } catch (error) {
+      handleError2(error, globalOpts.format);
+    }
+  });
+  tasksShowCmd.action(async (taskId) => {
+    const globalOpts = resolveGlobalOptions2(program2);
+    const showOpts = tasksShowCmd.opts();
+    try {
+      const config2 = loadConfig(fsAdapter);
+      const oauth2Client = await getAuthenticatedClient(fsAdapter);
+      const tasksClient = createGoogleTasksClient(import_googleapis2.google.tasks({ version: "v1", auth: oauth2Client }));
+      const opts = {
+        client: tasksClient,
+        taskId,
+        format: globalOpts.format,
+        quiet: globalOpts.quiet,
+        write: (msg) => process.stdout.write(msg + `
+`),
+        configTaskLists: config2.task_lists
+      };
+      if (showOpts.list !== undefined)
+        opts.list = showOpts.list;
+      const result = await handleTaskShow(opts);
+      process.exit(result.exitCode);
+    } catch (error) {
+      handleError2(error, globalOpts.format);
+    }
+  });
+  tasksAddCmd.action(async () => {
+    const addOpts = tasksAddCmd.opts();
+    await runTaskAction(program2, (deps) => {
+      const opts = { ...deps, title: addOpts.title };
+      if (addOpts.notes !== undefined)
+        opts.notes = addOpts.notes;
+      if (addOpts.due !== undefined)
+        opts.due = addOpts.due;
+      if (addOpts.list !== undefined)
+        opts.list = addOpts.list;
+      if (addOpts.parent !== undefined)
+        opts.parent = addOpts.parent;
+      return handleTaskAdd(opts);
+    });
+  });
+  tasksUpdateCmd.action(async (taskId) => {
+    const updateOpts = tasksUpdateCmd.opts();
+    await runTaskAction(program2, (deps) => {
+      const opts = { ...deps, taskId };
+      if (updateOpts.title !== undefined)
+        opts.title = updateOpts.title;
+      if (updateOpts.notes !== undefined)
+        opts.notes = updateOpts.notes;
+      if (updateOpts.due !== undefined)
+        opts.due = updateOpts.due;
+      if (updateOpts.list !== undefined)
+        opts.list = updateOpts.list;
+      return handleTaskUpdate(opts);
+    });
+  });
+  tasksDoneCmd.action(async (taskId) => {
+    const doneOpts = tasksDoneCmd.opts();
+    await runTaskAction(program2, (deps) => {
+      const opts = { ...deps, taskId };
+      if (doneOpts.list !== undefined)
+        opts.list = doneOpts.list;
+      return handleTaskDone(opts);
+    });
+  });
+  tasksUndoneCmd.action(async (taskId) => {
+    const undoneOpts = tasksUndoneCmd.opts();
+    await runTaskAction(program2, (deps) => {
+      const opts = { ...deps, taskId };
+      if (undoneOpts.list !== undefined)
+        opts.list = undoneOpts.list;
+      return handleTaskUndone(opts);
+    });
+  });
+  tasksDeleteCmd.action(async (taskId) => {
+    const deleteOpts = tasksDeleteCmd.opts();
+    await runTaskAction(program2, (deps) => {
+      const opts = { ...deps, taskId };
+      if (deleteOpts.list !== undefined)
+        opts.list = deleteOpts.list;
+      return handleTaskDelete(opts);
+    });
+  });
+  program2.addCommand(tasksCmd);
   const listCmd = createListCommand();
   listCmd.action(async () => {
     const globalOpts = resolveGlobalOptions2(program2);
     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),
@@ -592696,8 +593510,7 @@ ${url}`);
       const handleOpts = {
         ...listOpts,
         format: globalOpts.format,
-        quiet: globalOpts.quiet,
-        calendar: globalOpts.calendar
+        quiet: globalOpts.quiet
       };
       if (globalOpts.timezone)
         handleOpts.timezone = globalOpts.timezone;
@@ -592718,11 +593531,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,
@@ -592744,7 +593558,7 @@ ${url}`);
   });
   program2.addCommand(searchCmd);
   const showCmd = createShowCommand();
-  showCmd.action(async () => {
+  showCmd.action(async (eventId) => {
     const globalOpts = resolveGlobalOptions2(program2);
     const showOpts = showCmd.opts();
     try {
@@ -592752,23 +593566,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 + `
 `)
@@ -592789,8 +593604,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);
@@ -592834,10 +593649,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);
@@ -592868,6 +593685,11 @@ ${url}`);
           const api2 = await getApi();
           return listCalendars(api2);
         },
+        listTaskLists: async () => {
+          const oauth2Client = await getAuthenticatedClient(fsAdapter);
+          const tasksClient = createGoogleTasksClient(import_googleapis2.google.tasks({ version: "v1", auth: oauth2Client }));
+          return listTaskLists(tasksClient);
+        },
         requestAuth: async () => {
           apiRef = null;
           const promptFn = createReadlinePrompt();
@@ -592887,6 +593709,8 @@ ${authUrl}`);
         format: globalOpts.format,
         quiet: globalOpts.quiet,
         write,
+        writeErr: (msg) => process.stderr.write(msg + `
+`),
         force: initOpts.force ?? false,
         all: initOpts.all ?? false,
         local: initOpts.local ?? false,
@@ -592910,8 +593734,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);
@@ -592924,6 +593748,7 @@ ${authUrl}`);
         calendarId: cal.id,
         calendarName: cal.name,
         format: globalOpts.format,
+        quiet: globalOpts.quiet,
         timezone,
         write: (msg) => process.stdout.write(msg + `
 `),