@ncukondo/gcal-cli 0.4.0 → 0.5.0

package/dist/index.js

@@ -587754,7 +587754,7 @@ function errorCodeToExitCode(code) {
 // package.json
 var package_default = {
   name: "@ncukondo/gcal-cli",
-  version: "0.4.0",
+  version: "0.5.0",
   type: "module",
   exports: {
     ".": "./dist/index.js"
@@ -588022,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) {
@@ -588221,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;
@@ -588230,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) {
@@ -588394,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) {
@@ -588452,6 +588455,47 @@ var fsAdapter = {
 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: {
@@ -590895,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) {
@@ -591731,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";
@@ -591738,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;
@@ -591774,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)}"`);
@@ -591787,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(`
 `);
 }
@@ -592459,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}
@@ -592503,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) => ({
@@ -592524,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("");
@@ -592532,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}`);
   }
@@ -592546,6 +592640,553 @@ function createInitCommand() {
   return cmd;
 }
 
+// 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 {
+    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`);
+      }
+      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
 var FormatSchema2 = _enum(["text", "json"]);
 function resolveGlobalOptions2(program2) {
@@ -592632,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 () => {
@@ -592689,6 +593349,149 @@ ${url}`);
     }
   });
   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);
@@ -592882,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();
@@ -592901,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,

package/package.json

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