@stephendolan/omnifocus-cli 2.0.0 → 2.2.1

package/dist/{index.js → cli.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 
-// src/index.ts
+// src/cli.ts
 import { Command as Command8 } from "commander";
 
 // src/lib/output.ts
@@ -17,9 +17,45 @@ function outputJson(data, options = {}) {
 // src/commands/task.ts
 import { Command } from "commander";
 
+// src/lib/errors.ts
+var OmniFocusCliError = class extends Error {
+  constructor(message, statusCode = 500) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "OmniFocusCliError";
+  }
+};
+function handleError(error) {
+  let name = "unknown_error";
+  let detail = "An unknown error occurred";
+  let statusCode = 500;
+  if (error instanceof OmniFocusCliError) {
+    name = "cli_error";
+    detail = error.message;
+    statusCode = error.statusCode;
+  } else if (error instanceof Error) {
+    name = "omnifocus_error";
+    detail = error.message;
+    if (detail.includes("not found")) {
+      statusCode = 404;
+    } else if (detail.includes("Multiple")) {
+      statusCode = 400;
+    }
+  }
+  outputJson({ error: { name, detail, statusCode } });
+  process.exit(1);
+}
+
 // src/lib/command-utils.ts
-import ora from "ora";
-import chalk from "chalk";
+function withErrorHandling(fn) {
+  return async (...args) => {
+    try {
+      await fn(...args);
+    } catch (error) {
+      handleError(error);
+    }
+  };
+}
 
 // src/lib/omnifocus.ts
 import { execFile } from "child_process";
@@ -333,7 +369,7 @@ var OmniFocus = class {
       updates.push(`task.flagged = ${options.flagged};`);
     }
     if (options.completed !== void 0) {
-      updates.push(`task.completed = ${options.completed};`);
+      updates.push(options.completed ? "task.markComplete();" : "task.markIncomplete();");
     }
     if (options.estimatedMinutes !== void 0) {
       updates.push(`task.estimatedMinutes = ${options.estimatedMinutes};`);
@@ -945,109 +981,94 @@ var OmniFocus = class {
   }
 };
 
-// src/lib/command-utils.ts
-async function executeCommand(loadingMessage, action, onSuccess, failureMessage) {
-  const spinner = ora(loadingMessage).start();
-  try {
-    const result = await action();
-    spinner.stop();
-    onSuccess?.(result);
-    return result;
-  } catch (error) {
-    spinner.fail(failureMessage || "Command failed");
-    console.error(chalk.red(error.message));
-    throw error;
+// src/lib/dates.ts
+import dayjs from "dayjs";
+function parseDateTime(input) {
+  const d = dayjs(input);
+  if (!d.isValid()) {
+    throw new OmniFocusCliError(`Invalid date: ${input}`, 400);
   }
-}
-async function executeOmniFocusCommand(loadingMessage, action, onSuccess, failureMessage) {
-  const of = new OmniFocus();
-  return executeCommand(loadingMessage, () => action(of), onSuccess, failureMessage);
+  return d.toISOString();
 }
 
 // src/commands/task.ts
 function createTaskCommand() {
   const command = new Command("task");
   command.description("Manage OmniFocus tasks");
-  command.command("list").alias("ls").description("List tasks").option("-f, --flagged", "Show only flagged tasks").option("-p, --project <name>", "Filter by project").option("-t, --tag <name>", "Filter by tag").option("-c, --completed", "Include completed tasks").action(async (options) => {
-    await executeOmniFocusCommand(
-      "Loading tasks...",
-      (of) => {
-        const filters = {
-          includeCompleted: options.completed,
-          ...options.flagged && { flagged: true },
-          ...options.project && { project: options.project },
-          ...options.tag && { tag: options.tag }
-        };
-        return of.listTasks(filters);
-      },
-      (tasks) => outputJson(tasks),
-      "Failed to load tasks"
-    );
-  });
-  command.command("create <name>").description("Create a new task").option("-p, --project <name>", "Assign to project").option("--note <text>", "Add note").option("-t, --tag <tags...>", "Add tags").option("-d, --due <date>", "Set due date (ISO format)").option("-D, --defer <date>", "Set defer date (ISO format)").option("-f, --flagged", "Flag the task").option("-e, --estimate <minutes>", "Estimated time in minutes", parseInt).action(async (name, options) => {
-    await executeOmniFocusCommand(
-      "Creating task...",
-      (of) => of.createTask({
+  command.command("list").alias("ls").description("List tasks").option("-f, --flagged", "Show only flagged tasks").option("-p, --project <name>", "Filter by project").option("-t, --tag <name>", "Filter by tag").option("-c, --completed", "Include completed tasks").action(
+    withErrorHandling(async (options) => {
+      const of = new OmniFocus();
+      const filters = {
+        includeCompleted: options.completed,
+        ...options.flagged && { flagged: true },
+        ...options.project && { project: options.project },
+        ...options.tag && { tag: options.tag }
+      };
+      const tasks = await of.listTasks(filters);
+      outputJson(tasks);
+    })
+  );
+  command.command("create <name>").description("Create a new task").option("-p, --project <name>", "Assign to project").option("--note <text>", "Add note").option("-t, --tag <tags...>", "Add tags").option("-d, --due <date>", "Set due date").option("-D, --defer <date>", "Set defer date").option("-f, --flagged", "Flag the task").option("-e, --estimate <minutes>", "Estimated time in minutes", parseInt).action(
+    withErrorHandling(async (name, options) => {
+      const of = new OmniFocus();
+      const task = await of.createTask({
         name,
         note: options.note,
         project: options.project,
         tags: options.tag,
-        due: options.due,
-        defer: options.defer,
+        due: options.due ? parseDateTime(options.due) : void 0,
+        defer: options.defer ? parseDateTime(options.defer) : void 0,
         flagged: options.flagged,
         estimatedMinutes: options.estimate
-      }),
-      (task) => outputJson(task),
-      "Failed to create task"
-    );
-  });
-  command.command("update <idOrName>").description("Update an existing task").option("-n, --name <name>", "New name").option("--note <text>", "New note").option("-p, --project <name>", "Move to project").option("-t, --tag <tags...>", "Replace tags").option("-d, --due <date>", "Set due date (ISO format)").option("-D, --defer <date>", "Set defer date (ISO format)").option("-f, --flag", "Flag the task").option("-F, --unflag", "Unflag the task").option("-c, --complete", "Mark as completed").option("-C, --incomplete", "Mark as incomplete").option("-e, --estimate <minutes>", "Estimated time in minutes", parseInt).action(async (idOrName, options) => {
-    await executeOmniFocusCommand(
-      "Updating task...",
-      (of) => {
-        const updates = {
-          ...options.name && { name: options.name },
-          ...options.note !== void 0 && { note: options.note },
-          ...options.project && { project: options.project },
-          ...options.tag && { tags: options.tag },
-          ...options.due !== void 0 && { due: options.due },
-          ...options.defer !== void 0 && { defer: options.defer },
-          ...options.flag && { flagged: true },
-          ...options.unflag && { flagged: false },
-          ...options.complete && { completed: true },
-          ...options.incomplete && { completed: false },
-          ...options.estimate !== void 0 && { estimatedMinutes: options.estimate }
-        };
-        return of.updateTask(idOrName, updates);
-      },
-      (task) => outputJson(task),
-      "Failed to update task"
-    );
-  });
-  command.command("delete <idOrName>").alias("rm").description("Delete a task").action(async (idOrName) => {
-    await executeOmniFocusCommand(
-      "Deleting task...",
-      (of) => of.deleteTask(idOrName),
-      () => outputJson({ message: "Task deleted successfully" }),
-      "Failed to delete task"
-    );
-  });
-  command.command("view <idOrName>").description("View task details").action(async (idOrName) => {
-    await executeOmniFocusCommand(
-      "Loading task...",
-      (of) => of.getTask(idOrName),
-      (task) => outputJson(task),
-      "Failed to load task"
-    );
-  });
-  command.command("stats").description("Show task statistics").action(async () => {
-    await executeOmniFocusCommand(
-      "Analyzing tasks...",
-      (of) => of.getTaskStats(),
-      (stats) => outputJson(stats),
-      "Failed to analyze tasks"
-    );
-  });
+      });
+      outputJson(task);
+    })
+  );
+  command.command("update <idOrName>").description("Update an existing task").option("-n, --name <name>", "New name").option("--note <text>", "New note").option("-p, --project <name>", "Move to project").option("-t, --tag <tags...>", "Replace tags").option("-d, --due <date>", "Set due date").option("-D, --defer <date>", "Set defer date").option("-f, --flag", "Flag the task").option("-F, --unflag", "Unflag the task").option("-c, --complete", "Mark as completed").option("-C, --incomplete", "Mark as incomplete").option("-e, --estimate <minutes>", "Estimated time in minutes", parseInt).action(
+    withErrorHandling(async (idOrName, options) => {
+      const of = new OmniFocus();
+      const updates = {
+        ...options.name && { name: options.name },
+        ...options.note !== void 0 && { note: options.note },
+        ...options.project && { project: options.project },
+        ...options.tag && { tags: options.tag },
+        ...options.due !== void 0 && {
+          due: options.due ? parseDateTime(options.due) : null
+        },
+        ...options.defer !== void 0 && {
+          defer: options.defer ? parseDateTime(options.defer) : null
+        },
+        ...options.flag && { flagged: true },
+        ...options.unflag && { flagged: false },
+        ...options.complete && { completed: true },
+        ...options.incomplete && { completed: false },
+        ...options.estimate !== void 0 && { estimatedMinutes: options.estimate }
+      };
+      const task = await of.updateTask(idOrName, updates);
+      outputJson(task);
+    })
+  );
+  command.command("delete <idOrName>").alias("rm").description("Delete a task").action(
+    withErrorHandling(async (idOrName) => {
+      const of = new OmniFocus();
+      await of.deleteTask(idOrName);
+      outputJson({ message: "Task deleted successfully" });
+    })
+  );
+  command.command("view <idOrName>").description("View task details").action(
+    withErrorHandling(async (idOrName) => {
+      const of = new OmniFocus();
+      const task = await of.getTask(idOrName);
+      outputJson(task);
+    })
+  );
+  command.command("stats").description("Show task statistics").action(
+    withErrorHandling(async () => {
+      const of = new OmniFocus();
+      const stats = await of.getTaskStats();
+      outputJson(stats);
+    })
+  );
   return command;
 }
 
@@ -1056,79 +1077,69 @@ import { Command as Command2 } from "commander";
 function createProjectCommand() {
   const command = new Command2("project");
   command.description("Manage OmniFocus projects");
-  command.command("list").alias("ls").description("List projects").option("-f, --folder <name>", "Filter by folder").option("-s, --status <status>", "Filter by status (active, on hold, dropped)").option("-d, --dropped", "Include dropped projects").action(async (options) => {
-    await executeOmniFocusCommand(
-      "Loading projects...",
-      (of) => {
-        const filters = {
-          includeDropped: options.dropped,
-          ...options.folder && { folder: options.folder },
-          ...options.status && { status: options.status }
-        };
-        return of.listProjects(filters);
-      },
-      (projects) => outputJson(projects),
-      "Failed to load projects"
-    );
-  });
-  command.command("create <name>").description("Create a new project").option("-f, --folder <name>", "Assign to folder").option("--note <text>", "Add note").option("-t, --tag <tags...>", "Add tags").option("-s, --sequential", "Make it a sequential project").option("--status <status>", "Set status (active, on hold, dropped)").action(async (name, options) => {
-    await executeOmniFocusCommand(
-      "Creating project...",
-      (of) => of.createProject({
+  command.command("list").alias("ls").description("List projects").option("-f, --folder <name>", "Filter by folder").option("-s, --status <status>", "Filter by status (active, on hold, dropped)").option("-d, --dropped", "Include dropped projects").action(
+    withErrorHandling(async (options) => {
+      const of = new OmniFocus();
+      const filters = {
+        includeDropped: options.dropped,
+        ...options.folder && { folder: options.folder },
+        ...options.status && { status: options.status }
+      };
+      const projects = await of.listProjects(filters);
+      outputJson(projects);
+    })
+  );
+  command.command("create <name>").description("Create a new project").option("-f, --folder <name>", "Assign to folder").option("--note <text>", "Add note").option("-t, --tag <tags...>", "Add tags").option("-s, --sequential", "Make it a sequential project").option("--status <status>", "Set status (active, on hold, dropped)").action(
+    withErrorHandling(async (name, options) => {
+      const of = new OmniFocus();
+      const project = await of.createProject({
         name,
         note: options.note,
         folder: options.folder,
         tags: options.tag,
         sequential: options.sequential,
         status: options.status
-      }),
-      (project) => outputJson(project),
-      "Failed to create project"
-    );
-  });
-  command.command("update <idOrName>").description("Update an existing project").option("-n, --name <name>", "Rename project").option("--note <text>", "New note").option("-f, --folder <name>", "Move to folder").option("-t, --tag <tags...>", "Replace tags").option("-s, --sequential", "Make it sequential").option("-p, --parallel", "Make it parallel").option("--status <status>", "Set status (active, on hold, dropped)").action(async (idOrName, options) => {
-    await executeOmniFocusCommand(
-      "Updating project...",
-      (of) => {
-        const updates = {
-          ...options.name && { name: options.name },
-          ...options.note !== void 0 && { note: options.note },
-          ...options.folder && { folder: options.folder },
-          ...options.tag && { tags: options.tag },
-          ...options.sequential && { sequential: true },
-          ...options.parallel && { sequential: false },
-          ...options.status && { status: options.status }
-        };
-        return of.updateProject(idOrName, updates);
-      },
-      (project) => outputJson(project),
-      "Failed to update project"
-    );
-  });
-  command.command("delete <idOrName>").alias("rm").description("Delete a project").action(async (idOrName) => {
-    await executeOmniFocusCommand(
-      "Deleting project...",
-      (of) => of.deleteProject(idOrName),
-      () => outputJson({ message: "Project deleted successfully" }),
-      "Failed to delete project"
-    );
-  });
-  command.command("view <idOrName>").description("View project details").action(async (idOrName) => {
-    await executeOmniFocusCommand(
-      "Loading project...",
-      (of) => of.getProject(idOrName),
-      (project) => outputJson(project),
-      "Failed to load project"
-    );
-  });
-  command.command("stats").description("Show project statistics").action(async () => {
-    await executeOmniFocusCommand(
-      "Analyzing projects...",
-      (of) => of.getProjectStats(),
-      (stats) => outputJson(stats),
-      "Failed to analyze projects"
-    );
-  });
+      });
+      outputJson(project);
+    })
+  );
+  command.command("update <idOrName>").description("Update an existing project").option("-n, --name <name>", "Rename project").option("--note <text>", "New note").option("-f, --folder <name>", "Move to folder").option("-t, --tag <tags...>", "Replace tags").option("-s, --sequential", "Make it sequential").option("-p, --parallel", "Make it parallel").option("--status <status>", "Set status (active, on hold, dropped)").action(
+    withErrorHandling(async (idOrName, options) => {
+      const of = new OmniFocus();
+      const updates = {
+        ...options.name && { name: options.name },
+        ...options.note !== void 0 && { note: options.note },
+        ...options.folder && { folder: options.folder },
+        ...options.tag && { tags: options.tag },
+        ...options.sequential && { sequential: true },
+        ...options.parallel && { sequential: false },
+        ...options.status && { status: options.status }
+      };
+      const project = await of.updateProject(idOrName, updates);
+      outputJson(project);
+    })
+  );
+  command.command("delete <idOrName>").alias("rm").description("Delete a project").action(
+    withErrorHandling(async (idOrName) => {
+      const of = new OmniFocus();
+      await of.deleteProject(idOrName);
+      outputJson({ message: "Project deleted successfully" });
+    })
+  );
+  command.command("view <idOrName>").description("View project details").action(
+    withErrorHandling(async (idOrName) => {
+      const of = new OmniFocus();
+      const project = await of.getProject(idOrName);
+      outputJson(project);
+    })
+  );
+  command.command("stats").description("Show project statistics").action(
+    withErrorHandling(async () => {
+      const of = new OmniFocus();
+      const stats = await of.getProjectStats();
+      outputJson(stats);
+    })
+  );
   return command;
 }
 
@@ -1137,22 +1148,35 @@ import { Command as Command3 } from "commander";
 function createInboxCommand() {
   const command = new Command3("inbox");
   command.description("Manage OmniFocus inbox");
-  command.command("list").alias("ls").description("List inbox tasks").action(async () => {
-    await executeOmniFocusCommand(
-      "Loading inbox...",
-      (of) => of.listInboxTasks(),
-      (tasks) => outputJson(tasks),
-      "Failed to load inbox"
-    );
-  });
-  command.command("count").description("Get inbox count").action(async () => {
-    await executeOmniFocusCommand(
-      "Counting inbox items...",
-      (of) => of.getInboxCount(),
-      (count) => outputJson({ count }),
-      "Failed to get inbox count"
-    );
-  });
+  command.command("list").alias("ls").description("List inbox tasks").action(
+    withErrorHandling(async () => {
+      const of = new OmniFocus();
+      const tasks = await of.listInboxTasks();
+      outputJson(tasks);
+    })
+  );
+  command.command("count").description("Get inbox count").action(
+    withErrorHandling(async () => {
+      const of = new OmniFocus();
+      const count = await of.getInboxCount();
+      outputJson({ count });
+    })
+  );
+  command.command("add <name>").description("Add a task to inbox").option("--note <text>", "Add note").option("-t, --tag <tags...>", "Add tags").option("-d, --due <date>", "Set due date").option("-D, --defer <date>", "Set defer date").option("-f, --flagged", "Flag the task").option("-e, --estimate <minutes>", "Estimated time in minutes", parseInt).action(
+    withErrorHandling(async (name, options) => {
+      const of = new OmniFocus();
+      const task = await of.createTask({
+        name,
+        note: options.note,
+        tags: options.tag,
+        due: options.due ? parseDateTime(options.due) : void 0,
+        defer: options.defer ? parseDateTime(options.defer) : void 0,
+        flagged: options.flagged,
+        estimatedMinutes: options.estimate
+      });
+      outputJson(task);
+    })
+  );
   return command;
 }
 
@@ -1162,14 +1186,13 @@ function createSearchCommand() {
   const command = new Command4("search");
   command.description("Search tasks by name or note");
   command.argument("<query>", "Search query");
-  command.action(async (query) => {
-    await executeOmniFocusCommand(
-      "Searching...",
-      (of) => of.searchTasks(query),
-      (tasks) => outputJson(tasks),
-      "Search failed"
-    );
-  });
+  command.action(
+    withErrorHandling(async (query) => {
+      const of = new OmniFocus();
+      const tasks = await of.searchTasks(query);
+      outputJson(tasks);
+    })
+  );
   return command;
 }
 
@@ -1178,22 +1201,20 @@ import { Command as Command5 } from "commander";
 function createPerspectiveCommand() {
   const command = new Command5("perspective");
   command.description("Manage OmniFocus perspectives");
-  command.command("list").alias("ls").description("List all perspectives").action(async () => {
-    await executeOmniFocusCommand(
-      "Loading perspectives...",
-      (of) => of.listPerspectives(),
-      (perspectives) => outputJson(perspectives),
-      "Failed to load perspectives"
-    );
-  });
-  command.command("view <name>").description("View tasks in a perspective").action(async (name) => {
-    await executeOmniFocusCommand(
-      `Loading perspective "${name}"...`,
-      (of) => of.getPerspectiveTasks(name),
-      (tasks) => outputJson(tasks),
-      "Failed to load perspective"
-    );
-  });
+  command.command("list").alias("ls").description("List all perspectives").action(
+    withErrorHandling(async () => {
+      const of = new OmniFocus();
+      const perspectives = await of.listPerspectives();
+      outputJson(perspectives);
+    })
+  );
+  command.command("view <name>").description("View tasks in a perspective").action(
+    withErrorHandling(async (name) => {
+      const of = new OmniFocus();
+      const tasks = await of.getPerspectiveTasks(name);
+      outputJson(tasks);
+    })
+  );
   return command;
 }
 
@@ -1202,68 +1223,60 @@ import { Command as Command6 } from "commander";
 function createTagCommand() {
   const command = new Command6("tag");
   command.description("Manage and analyze OmniFocus tags");
-  command.command("list").alias("ls").description("List tags with usage information").option("-u, --unused-days <days>", "Show tags unused for N days", parseInt).option("-s, --sort <field>", "Sort by: name, usage, activity (default: name)", "name").option("-a, --active-only", "Only count active (incomplete) tasks").action(async (options) => {
-    await executeOmniFocusCommand(
-      "Loading tags...",
-      (of) => of.listTags({
+  command.command("list").alias("ls").description("List tags with usage information").option("-u, --unused-days <days>", "Show tags unused for N days", parseInt).option("-s, --sort <field>", "Sort by: name, usage, activity (default: name)", "name").option("-a, --active-only", "Only count active (incomplete) tasks").action(
+    withErrorHandling(async (options) => {
+      const of = new OmniFocus();
+      const tags = await of.listTags({
         unusedDays: options.unusedDays,
         sortBy: options.sort,
         activeOnly: options.activeOnly
-      }),
-      (tags) => outputJson(tags),
-      "Failed to load tags"
-    );
-  });
-  command.command("create <name>").description("Create a new tag").option("-p, --parent <name>", "Create as child of parent tag").option("-s, --status <status>", "Set status (active, on hold, dropped)").action(async (name, options) => {
-    await executeOmniFocusCommand(
-      "Creating tag...",
-      (of) => of.createTag({
+      });
+      outputJson(tags);
+    })
+  );
+  command.command("create <name>").description("Create a new tag").option("-p, --parent <name>", "Create as child of parent tag").option("-s, --status <status>", "Set status (active, on hold, dropped)").action(
+    withErrorHandling(async (name, options) => {
+      const of = new OmniFocus();
+      const tag = await of.createTag({
         name,
         parent: options.parent,
         status: options.status
-      }),
-      (tag) => outputJson(tag),
-      "Failed to create tag"
-    );
-  });
-  command.command("view <idOrName>").description("View tag details").action(async (idOrName) => {
-    await executeOmniFocusCommand(
-      "Loading tag...",
-      (of) => of.getTag(idOrName),
-      (tag) => outputJson(tag),
-      "Failed to load tag"
-    );
-  });
-  command.command("update <idOrName>").description("Update an existing tag").option("-n, --name <name>", "Rename tag").option("-s, --status <status>", "Set status (active, on hold, dropped)").action(async (idOrName, options) => {
-    await executeOmniFocusCommand(
-      "Updating tag...",
-      (of) => {
-        const updates = {
-          ...options.name && { name: options.name },
-          ...options.status && { status: options.status }
-        };
-        return of.updateTag(idOrName, updates);
-      },
-      (tag) => outputJson(tag),
-      "Failed to update tag"
-    );
-  });
-  command.command("delete <idOrName>").alias("rm").description("Delete a tag").action(async (idOrName) => {
-    await executeOmniFocusCommand(
-      "Deleting tag...",
-      (of) => of.deleteTag(idOrName),
-      () => outputJson({ message: "Tag deleted successfully" }),
-      "Failed to delete tag"
-    );
-  });
-  command.command("stats").description("Show tag usage statistics").action(async () => {
-    await executeOmniFocusCommand(
-      "Analyzing tags...",
-      (of) => of.getTagStats(),
-      (stats) => outputJson(stats),
-      "Failed to analyze tags"
-    );
-  });
+      });
+      outputJson(tag);
+    })
+  );
+  command.command("view <idOrName>").description("View tag details").action(
+    withErrorHandling(async (idOrName) => {
+      const of = new OmniFocus();
+      const tag = await of.getTag(idOrName);
+      outputJson(tag);
+    })
+  );
+  command.command("update <idOrName>").description("Update an existing tag").option("-n, --name <name>", "Rename tag").option("-s, --status <status>", "Set status (active, on hold, dropped)").action(
+    withErrorHandling(async (idOrName, options) => {
+      const of = new OmniFocus();
+      const updates = {
+        ...options.name && { name: options.name },
+        ...options.status && { status: options.status }
+      };
+      const tag = await of.updateTag(idOrName, updates);
+      outputJson(tag);
+    })
+  );
+  command.command("delete <idOrName>").alias("rm").description("Delete a tag").action(
+    withErrorHandling(async (idOrName) => {
+      const of = new OmniFocus();
+      await of.deleteTag(idOrName);
+      outputJson({ message: "Tag deleted successfully" });
+    })
+  );
+  command.command("stats").description("Show tag usage statistics").action(
+    withErrorHandling(async () => {
+      const of = new OmniFocus();
+      const stats = await of.getTagStats();
+      outputJson(stats);
+    })
+  );
   return command;
 }
 
@@ -1272,29 +1285,27 @@ import { Command as Command7 } from "commander";
 function createFolderCommand() {
   const command = new Command7("folder");
   command.description("View OmniFocus folder hierarchy");
-  command.command("list").alias("ls").description("List top-level folders with nested children").option("-d, --dropped", "Include dropped folders").action(async (options) => {
-    await executeOmniFocusCommand(
-      "Loading folders...",
-      (of) => of.listFolders({ includeDropped: options.dropped }),
-      (folders) => outputJson(folders),
-      "Failed to load folders"
-    );
-  });
-  command.command("view <idOrName>").description("View folder details and children").option("-d, --dropped", "Include dropped child folders").action(async (idOrName, options) => {
-    const filters = { includeDropped: options.dropped };
-    await executeOmniFocusCommand(
-      "Loading folder...",
-      (of) => of.getFolder(idOrName, filters),
-      (folder) => outputJson(folder),
-      "Failed to load folder"
-    );
-  });
+  command.command("list").alias("ls").description("List top-level folders with nested children").option("-d, --dropped", "Include dropped folders").action(
+    withErrorHandling(async (options) => {
+      const of = new OmniFocus();
+      const folders = await of.listFolders({ includeDropped: options.dropped });
+      outputJson(folders);
+    })
+  );
+  command.command("view <idOrName>").description("View folder details and children").option("-d, --dropped", "Include dropped child folders").action(
+    withErrorHandling(async (idOrName, options) => {
+      const of = new OmniFocus();
+      const filters = { includeDropped: options.dropped };
+      const folder = await of.getFolder(idOrName, filters);
+      outputJson(folder);
+    })
+  );
   return command;
 }
 
-// src/index.ts
+// src/cli.ts
 var program = new Command8();
-program.name("of").description("A command-line interface for OmniFocus on macOS").version("2.0.0").option("-c, --compact", "Minified JSON output (single line)").hook("preAction", (thisCommand) => {
+program.name("of").description("A command-line interface for OmniFocus on macOS").version("2.2.1").option("-c, --compact", "Minified JSON output (single line)").hook("preAction", (thisCommand) => {
   const options = thisCommand.opts();
   setOutputOptions({
     compact: options.compact
@@ -1310,4 +1321,4 @@ program.addCommand(createFolderCommand());
 program.parseAsync().catch(() => {
   process.exit(1);
 });
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=cli.js.map