@mindtnv/todoist-cli 0.3.1 → 0.5.0

package/src/utils/colors.ts

@@ -0,0 +1,27 @@
+/** Maps Todoist API color names to terminal-compatible color strings. */
+export const todoistColorMap: Record<string, string> = {
+  berry_red: "red",
+  red: "red",
+  orange: "yellow",
+  yellow: "yellow",
+  olive_green: "green",
+  lime_green: "green",
+  green: "green",
+  mint_green: "green",
+  teal: "cyan",
+  sky_blue: "cyan",
+  light_blue: "blue",
+  blue: "blue",
+  grape: "magenta",
+  violet: "magenta",
+  lavender: "magenta",
+  magenta: "magenta",
+  salmon: "red",
+  charcoal: "gray",
+  grey: "gray",
+  taupe: "gray",
+};
+
+export function mapTodoistColor(color: string): string {
+  return todoistColorMap[color] ?? "cyan";
+}

package/src/utils/date-format.ts

@@ -0,0 +1,54 @@
+const SHORT_MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+const FULL_MONTHS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+
+function getTodayString(): string {
+  const today = new Date();
+  return `${today.getFullYear()}-${String(today.getMonth() + 1).padStart(2, "0")}-${String(today.getDate()).padStart(2, "0")}`;
+}
+
+export function formatDeadlineShort(dateStr: string): string {
+  const parts = dateStr.split("-").map(Number);
+  const m = parts[1] ?? 1;
+  const d = parts[2] ?? 1;
+  return `${SHORT_MONTHS[m - 1]} ${d}`;
+}
+
+export function formatDeadlineLong(dateStr: string): string {
+  const parts = dateStr.split("-").map(Number);
+  const y = parts[0] ?? 2025;
+  const m = parts[1] ?? 1;
+  const d = parts[2] ?? 1;
+  return `${FULL_MONTHS[m - 1]} ${d}, ${y}`;
+}
+
+export function isDeadlineUrgent(dateStr: string): boolean {
+  const todayStr = getTodayString();
+  const deadline = new Date(dateStr + "T00:00:00");
+  const now = new Date(todayStr + "T00:00:00");
+  const diffDays = (deadline.getTime() - now.getTime()) / (1000 * 60 * 60 * 24);
+  return diffDays <= 3;
+}
+
+export function isDeadlineOverdue(dateStr: string): boolean {
+  return dateStr < getTodayString();
+}
+
+export function formatRelativeDue(dateStr: string): { text: string; color: string } {
+  const todayStr = getTodayString();
+  const todayDate = new Date(todayStr + "T00:00:00");
+  const dueDate = new Date(dateStr.slice(0, 10) + "T00:00:00");
+  const diffDays = Math.round((dueDate.getTime() - todayDate.getTime()) / (1000 * 60 * 60 * 24));
+
+  if (diffDays < 0) return { text: "overdue", color: "red" };
+  if (diffDays === 0) return { text: "today", color: "green" };
+  if (diffDays === 1) return { text: "tomorrow", color: "yellow" };
+
+  const m = dueDate.getMonth();
+  const d = dueDate.getDate();
+  return { text: `${SHORT_MONTHS[m]} ${d}`, color: "cyan" };
+}
+
+export function formatCreatedAt(isoString: string): string {
+  const d = new Date(isoString);
+  return `${FULL_MONTHS[d.getMonth()]} ${d.getDate()}, ${d.getFullYear()} at ${d.getHours()}:${String(d.getMinutes()).padStart(2, "0")}`;
+}

package/src/utils/errors.ts

@@ -0,0 +1,159 @@
+import chalk from "chalk";
+
+export const EXIT_OK = 0;
+export const EXIT_USAGE = 2;
+export const EXIT_AUTH = 3;
+export const EXIT_NETWORK = 4;
+export const EXIT_NOT_FOUND = 5;
+
+export enum ErrorCode {
+  AUTH_FAILED = "AUTH_FAILED",
+  RATE_LIMITED = "RATE_LIMITED",
+  NOT_FOUND = "NOT_FOUND",
+  VALIDATION = "VALIDATION",
+  NETWORK = "NETWORK",
+  UNKNOWN = "UNKNOWN",
+}
+
+let DEBUG = false;
+
+export function setDebug(value: boolean): void {
+  DEBUG = value;
+}
+
+export function isDebug(): boolean {
+  return DEBUG;
+}
+
+export function debug(...args: unknown[]): void {
+  if (DEBUG) console.error("[debug]", ...args);
+}
+
+export class CliError extends Error {
+  code: number;
+  errorCode: ErrorCode;
+  suggestion?: string;
+  helpUrl?: string;
+
+  constructor(message: string, opts: { code: number; errorCode?: ErrorCode; suggestion?: string; helpUrl?: string }) {
+    super(message);
+    this.name = "CliError";
+    this.code = opts.code;
+    this.errorCode = opts.errorCode ?? ErrorCode.UNKNOWN;
+    this.suggestion = opts.suggestion;
+    this.helpUrl = opts.helpUrl;
+  }
+}
+
+export function wrapApiError(err: unknown): CliError {
+  const message = err instanceof Error ? err.message : String(err);
+
+  debug("wrapApiError called with:", message);
+
+  // Check for HTTP status codes in the error message
+  const statusMatch = message.match(/\b(4\d{2}|5\d{2})\b/);
+  const statusCode = statusMatch ? parseInt(statusMatch[1]!, 10) : null;
+
+  if (message.includes("Authentication failed") || message.includes("401") || message.includes("403") || statusCode === 401 || statusCode === 403) {
+    return new CliError("Authentication failed. Run `todoist auth` to set your API token.", {
+      code: EXIT_AUTH,
+      errorCode: ErrorCode.AUTH_FAILED,
+      suggestion: "Run `todoist auth` to set a valid API token.",
+    });
+  }
+
+  if (message.includes("Rate limit") || message.includes("429") || statusCode === 429) {
+    return new CliError("Rate limit exceeded. Please wait a moment and try again.", {
+      code: EXIT_NETWORK,
+      errorCode: ErrorCode.RATE_LIMITED,
+      suggestion: "Wait a moment and try again. Todoist allows ~450 requests per 15 minutes.",
+    });
+  }
+
+  if (message.includes("404") || message.includes("not found") || statusCode === 404) {
+    return new CliError("Resource not found. The task/project may have been deleted.", {
+      code: EXIT_NOT_FOUND,
+      errorCode: ErrorCode.NOT_FOUND,
+      suggestion: "Check the ID and try again. The resource may have been deleted or moved.",
+    });
+  }
+
+  if (statusCode && statusCode >= 500) {
+    return new CliError("Todoist API is experiencing issues. Try again later.", {
+      code: EXIT_NETWORK,
+      errorCode: ErrorCode.NETWORK,
+      suggestion: "The Todoist servers are having problems. Check https://status.todoist.com for updates.",
+    });
+  }
+
+  if (message.includes("fetch") || message.includes("ECONNREFUSED") || message.includes("ENOTFOUND") || message.includes("ETIMEDOUT")) {
+    return new CliError("Network error — could not reach the Todoist API.", {
+      code: EXIT_NETWORK,
+      errorCode: ErrorCode.NETWORK,
+      suggestion: "Check your internet connection and try again.",
+    });
+  }
+
+  return new CliError(message, { code: 1, errorCode: ErrorCode.UNKNOWN });
+}
+
+export function formatCliError(err: CliError): string {
+  let out = chalk.red(`Error: ${err.message}`);
+  if (DEBUG) {
+    out += `\n${chalk.dim(`[${err.errorCode}] exit code: ${err.code}`)}`;
+    if (err.stack) {
+      out += `\n${chalk.dim(err.stack)}`;
+    }
+  }
+  if (err.suggestion) {
+    out += `\n${chalk.yellow("Hint:")} ${err.suggestion}`;
+  }
+  if (err.helpUrl) {
+    out += `\n${chalk.dim("More info:")} ${err.helpUrl}`;
+  }
+  return out;
+}
+
+function levenshtein(a: string, b: string): number {
+  const m = a.length;
+  const n = b.length;
+  const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0) as number[]);
+
+  for (let i = 0; i <= m; i++) dp[i]![0] = i;
+  for (let j = 0; j <= n; j++) dp[0]![j] = j;
+
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i]![j] = Math.min(
+        dp[i - 1]![j]! + 1,
+        dp[i]![j - 1]! + 1,
+        dp[i - 1]![j - 1]! + cost,
+      );
+    }
+  }
+
+  return dp[m]![n]!;
+}
+
+export function didYouMean(input: string, candidates: string[]): string | null {
+  let bestMatch: string | null = null;
+  let bestDist = Infinity;
+
+  for (const c of candidates) {
+    const dist = levenshtein(input.toLowerCase(), c.toLowerCase());
+    if (dist < bestDist && dist <= 3) {
+      bestDist = dist;
+      bestMatch = c;
+    }
+  }
+
+  return bestMatch;
+}
+
+export function handleError(err: unknown): never {
+  const cliErr = err instanceof CliError ? err : wrapApiError(err);
+  debug("handleError:", cliErr.errorCode, cliErr.message);
+  console.error(formatCliError(cliErr));
+  process.exit(cliErr.code);
+}

package/src/utils/exit.ts

@@ -0,0 +1,11 @@
+/**
+ * Wrappable process.exit for testability.
+ * In tests, override `cliExit` to throw instead of exiting.
+ */
+export let cliExit: (code?: number) => never = (code = 0) => {
+  process.exit(code);
+};
+
+export function setCLIExit(fn: (code?: number) => never): void {
+  cliExit = fn;
+}

package/src/utils/format.ts

@@ -0,0 +1,46 @@
+import chalk from "chalk";
+import type { Priority } from "../api/types.ts";
+
+export const ID_WIDTH = 18;
+export const PRI_WIDTH = 6;
+export const LABEL_WIDTH = 10;
+
+export function getContentWidth(): number {
+  const cols = process.stdout.columns || 80;
+  // Fixed columns: ID + Pri + Due + Labels + 4 spaces between columns
+  const fixed = ID_WIDTH + 1 + PRI_WIDTH + 1 + 1 + LABEL_WIDTH;
+  const remaining = cols - fixed;
+  // Split remaining between content and due (roughly 3:1)
+  return Math.max(20, Math.floor(remaining * 0.7));
+}
+
+export function getDueWidth(): number {
+  const cols = process.stdout.columns || 80;
+  const fixed = ID_WIDTH + 1 + PRI_WIDTH + 1 + 1 + LABEL_WIDTH;
+  const remaining = cols - fixed;
+  const contentWidth = Math.max(20, Math.floor(remaining * 0.7));
+  return Math.max(10, remaining - contentWidth);
+}
+
+export function padEnd(str: string, len: number): string {
+  const stripped = str.replace(/\x1b\[[0-9;]*m/g, "");
+  const pad = Math.max(0, len - stripped.length);
+  return str + " ".repeat(pad);
+}
+
+export function priorityColor(p: Priority): (text: string) => string {
+  switch (p) {
+    case 1: return chalk.white;
+    case 2: return chalk.blue;
+    case 3: return chalk.yellow;
+    case 4: return chalk.red;
+  }
+}
+
+export function priorityLabel(p: Priority): string {
+  return priorityColor(p)(`p${p}`);
+}
+
+export function truncate(str: string, maxLen: number): string {
+  return str.length > maxLen ? str.slice(0, maxLen - 1) + "..." : str;
+}

package/src/utils/open-url.ts

@@ -0,0 +1,9 @@
+import { spawn } from "node:child_process";
+
+export function openUrl(url: string): void {
+  const platform = process.platform;
+  if (platform === "darwin") spawn("open", [url], { stdio: "ignore", detached: true }).unref();
+  else if (platform === "linux") spawn("xdg-open", [url], { stdio: "ignore", detached: true }).unref();
+  else if (platform === "win32") spawn("cmd", ["/c", "start", url], { stdio: "ignore", detached: true }).unref();
+  else throw new Error(`Unsupported platform: ${platform}`);
+}

package/src/utils/output.ts

@@ -0,0 +1,29 @@
+import type { Task } from "../api/types.ts";
+
+function escapeCsvField(val: string, delimiter: string): string {
+  if (val.includes(delimiter) || val.includes('"') || val.includes("\n")) {
+    return `"${val.replace(/"/g, '""')}"`;
+  }
+  return val;
+}
+
+export function formatTasksDelimited(tasks: Task[], delimiter: string): string {
+  const headers = ["id", "content", "priority", "due_date", "deadline", "project_id", "labels", "description"];
+  const lines: string[] = [headers.join(delimiter)];
+
+  for (const t of tasks) {
+    const row = [
+      t.id,
+      escapeCsvField(t.content, delimiter),
+      String(t.priority),
+      t.due?.date ?? "",
+      t.deadline?.date ?? "",
+      t.project_id,
+      t.labels.join(";"),
+      escapeCsvField(t.description || "", delimiter),
+    ];
+    lines.push(row.join(delimiter));
+  }
+
+  return lines.join("\n");
+}

package/src/utils/quick-add.ts

@@ -0,0 +1,202 @@
+import type { Priority } from "../api/types.ts";
+import { getProjects } from "../api/projects.ts";
+
+export interface QuickAddResult {
+  content: string;
+  description?: string;
+  priority?: Priority;
+  labels: string[];
+  due_string?: string;
+  project_name?: string;
+  project_id?: string;
+  section_name?: string;
+  deadline?: string; // YYYY-MM-DD
+}
+
+const PRIORITY_RE = /\bp([1-4])\b/;
+const PROJECT_RE = /#"([^"]+)"|#'([^']+)'|#(\S+)/;
+const LABEL_RE = /@(\S+)/g;
+const SECTION_RE = /\/\/(\S+)/;
+const DEADLINE_RE = /\{(\d{4}-\d{2}-\d{2})\}/;
+
+// Description syntax: "// description text" (double slash + space separates description from content)
+const DESCRIPTION_RE = /\s+\/\/\s+(.*)/;
+
+// Recurrence syntax: !daily, !weekly, !monthly, !yearly, !weekdays, !every <text>
+const RECURRENCE_SIMPLE_RE = /!(daily|weekly|monthly|yearly|weekdays)\b/;
+const RECURRENCE_EVERY_RE = /!every\s+([^#@!{}\\/]+?)(?=\s+[#@!{p]|\s+\/\/|\s*$)/;
+
+// Relative date patterns: +Nd for days, +Nw for weeks
+const RELATIVE_DAYS_RE = /\+(\d+)d\b/;
+const RELATIVE_WEEKS_RE = /\+(\d+)w\b/;
+
+const DATE_KEYWORDS = [
+  "today",
+  "tomorrow",
+  "yesterday",
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday",
+  "sunday",
+  "next week",
+  "next month",
+  "every day",
+  "every week",
+  "every month",
+];
+
+function extractDatePhrase(text: string): { date: string; remaining: string } | null {
+  const lower = text.toLowerCase();
+  for (const keyword of DATE_KEYWORDS) {
+    const idx = lower.indexOf(keyword);
+    if (idx !== -1) {
+      const remaining = text.slice(0, idx) + text.slice(idx + keyword.length);
+      return { date: keyword, remaining: remaining.replace(/\s+/g, " ").trim() };
+    }
+  }
+
+  // Match patterns like "Jan 15", "2026-02-10", "Feb 3rd"
+  const datePatternRe = /\b(\d{4}-\d{2}-\d{2}|(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+\d{1,2}(?:st|nd|rd|th)?)\b/i;
+  const match = datePatternRe.exec(text);
+  if (match) {
+    const remaining = text.slice(0, match.index) + text.slice(match.index + match[0].length);
+    return { date: match[0], remaining: remaining.replace(/\s+/g, " ").trim() };
+  }
+
+  return null;
+}
+
+export function parseQuickAdd(input: string): QuickAddResult {
+  let text = input;
+  const labels: string[] = [];
+
+  // Extract description first: "// description text" (double slash + space)
+  // Must happen before section extraction since //SectionName (no space) is different
+  let description: string | undefined;
+  const descMatch = DESCRIPTION_RE.exec(text);
+  if (descMatch) {
+    description = descMatch[1]!.trim();
+    text = text.slice(0, descMatch.index).trim();
+  }
+
+  // Extract priority
+  let priority: Priority | undefined;
+  const priMatch = PRIORITY_RE.exec(text);
+  if (priMatch) {
+    priority = parseInt(priMatch[1]!, 10) as Priority;
+    text = text.replace(priMatch[0], "").trim();
+  }
+
+  // Extract deadline {YYYY-MM-DD} before project/section to avoid conflicts
+  let deadline: string | undefined;
+  const deadlineMatch = DEADLINE_RE.exec(text);
+  if (deadlineMatch) {
+    deadline = deadlineMatch[1]!;
+    text = text.replace(deadlineMatch[0], "").trim();
+  }
+
+  // Extract recurrence syntax: !daily, !weekly, !every <text>
+  let dueString: string | undefined;
+  const recurrenceSimpleMatch = RECURRENCE_SIMPLE_RE.exec(text);
+  const recurrenceEveryMatch = RECURRENCE_EVERY_RE.exec(text);
+
+  if (recurrenceEveryMatch) {
+    // !every takes precedence when it comes before simple recurrence
+    dueString = "every " + recurrenceEveryMatch[1]!.trim();
+    text = text.replace(recurrenceEveryMatch[0], "").trim();
+  } else if (recurrenceSimpleMatch) {
+    const keyword = recurrenceSimpleMatch[1]!;
+    // Map shorthand to Todoist-compatible due_string
+    const recurrenceMap: Record<string, string> = {
+      daily: "every day",
+      weekly: "every week",
+      monthly: "every month",
+      yearly: "every year",
+      weekdays: "every weekday",
+    };
+    dueString = recurrenceMap[keyword] ?? keyword;
+    text = text.replace(recurrenceSimpleMatch[0], "").trim();
+  }
+
+  // Extract relative date patterns: +Nd, +Nw
+  if (!dueString) {
+    const relativeDaysMatch = RELATIVE_DAYS_RE.exec(text);
+    if (relativeDaysMatch) {
+      const n = parseInt(relativeDaysMatch[1]!, 10);
+      dueString = n === 1 ? "in 1 day" : `in ${n} days`;
+      text = text.replace(relativeDaysMatch[0], "").trim();
+    } else {
+      const relativeWeeksMatch = RELATIVE_WEEKS_RE.exec(text);
+      if (relativeWeeksMatch) {
+        const n = parseInt(relativeWeeksMatch[1]!, 10);
+        dueString = n === 1 ? "in 1 week" : `in ${n} weeks`;
+        text = text.replace(relativeWeeksMatch[0], "").trim();
+      }
+    }
+  }
+
+  // Extract section (//SectionName) before project (#Name) to avoid conflicts
+  let sectionName: string | undefined;
+  const sectionMatch = SECTION_RE.exec(text);
+  if (sectionMatch) {
+    sectionName = sectionMatch[1]!;
+    text = text.replace(sectionMatch[0], "").trim();
+  }
+
+  // Extract project (supports #Name, #"Multi Word", #'Multi Word')
+  let projectName: string | undefined;
+  const projectMatch = PROJECT_RE.exec(text);
+  if (projectMatch) {
+    projectName = projectMatch[1] ?? projectMatch[2] ?? projectMatch[3]!;
+    text = text.replace(projectMatch[0], "").trim();
+  }
+
+  // Extract labels
+  LABEL_RE.lastIndex = 0;
+  let labelMatch: RegExpExecArray | null;
+  while ((labelMatch = LABEL_RE.exec(text)) !== null) {
+    labels.push(labelMatch[1]!);
+  }
+  text = text.replace(LABEL_RE, "").trim();
+
+  // Extract date keywords (only if no recurrence/relative date was already found)
+  if (!dueString) {
+    const dateResult = extractDatePhrase(text);
+    if (dateResult) {
+      dueString = dateResult.date;
+      text = dateResult.remaining;
+    }
+  }
+
+  // Clean up extra whitespace
+  text = text.replace(/\s+/g, " ").trim();
+
+  return {
+    content: text,
+    description,
+    priority,
+    labels,
+    due_string: dueString,
+    project_name: projectName,
+    section_name: sectionName,
+    deadline,
+  };
+}
+
+export async function resolveProjectName(name: string): Promise<string | undefined> {
+  const projects = await getProjects();
+  const lower = name.toLowerCase();
+  const found = projects.find((p) => p.name.toLowerCase() === lower);
+  return found?.id;
+}
+
+export async function resolveSectionName(name: string, projectId?: string): Promise<string | undefined> {
+  const { getSections } = await import("../api/sections.ts");
+  const sections = await getSections(projectId);
+  const lower = name.toLowerCase();
+  const found = sections.find((s) => s.name.toLowerCase() === lower);
+  return found?.id;
+}