@md2do/todoist 0.2.0

package/src/client.ts

@@ -0,0 +1,203 @@
+import { TodoistApi } from '@doist/todoist-api-typescript';
+import type { Task, Project, Label } from '@doist/todoist-api-typescript';
+import type { TodoistTaskParams } from './mapper.js';
+
+/**
+ * Configuration for Todoist client
+ */
+export interface TodoistClientConfig {
+  apiToken: string;
+}
+
+/**
+ * Wrapper around Todoist API with error handling and convenience methods
+ */
+export class TodoistClient {
+  private api: TodoistApi;
+
+  constructor(config: TodoistClientConfig) {
+    this.api = new TodoistApi(config.apiToken);
+  }
+
+  /**
+   * Get all active tasks
+   */
+  async getTasks(options?: {
+    projectId?: string;
+    labelId?: string;
+  }): Promise<Task[]> {
+    try {
+      return await this.api.getTasks(options);
+    } catch (error) {
+      throw new Error(
+        `Failed to get tasks: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  /**
+   * Get a specific task by ID
+   */
+  async getTask(taskId: string): Promise<Task> {
+    try {
+      return await this.api.getTask(taskId);
+    } catch (error) {
+      throw new Error(
+        `Failed to get task ${taskId}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  /**
+   * Create a new task
+   */
+  async createTask(
+    params: TodoistTaskParams | Record<string, unknown>,
+  ): Promise<Task> {
+    try {
+      return await this.api.addTask(params as TodoistTaskParams);
+    } catch (error) {
+      throw new Error(
+        `Failed to create task: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  /**
+   * Update an existing task
+   */
+  async updateTask(
+    taskId: string,
+    params: Partial<TodoistTaskParams>,
+  ): Promise<Task> {
+    try {
+      return await this.api.updateTask(taskId, params);
+    } catch (error) {
+      throw new Error(
+        `Failed to update task ${taskId}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  /**
+   * Complete a task
+   */
+  async completeTask(taskId: string): Promise<boolean> {
+    try {
+      return await this.api.closeTask(taskId);
+    } catch (error) {
+      throw new Error(
+        `Failed to complete task ${taskId}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  /**
+   * Reopen a completed task
+   */
+  async reopenTask(taskId: string): Promise<boolean> {
+    try {
+      return await this.api.reopenTask(taskId);
+    } catch (error) {
+      throw new Error(
+        `Failed to reopen task ${taskId}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  /**
+   * Delete a task
+   */
+  async deleteTask(taskId: string): Promise<boolean> {
+    try {
+      return await this.api.deleteTask(taskId);
+    } catch (error) {
+      throw new Error(
+        `Failed to delete task ${taskId}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  /**
+   * Get all projects
+   */
+  async getProjects(): Promise<Project[]> {
+    try {
+      return await this.api.getProjects();
+    } catch (error) {
+      throw new Error(
+        `Failed to get projects: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  /**
+   * Get a specific project by ID
+   */
+  async getProject(projectId: string): Promise<Project> {
+    try {
+      return await this.api.getProject(projectId);
+    } catch (error) {
+      throw new Error(
+        `Failed to get project ${projectId}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  /**
+   * Find project by name
+   */
+  async findProjectByName(name: string): Promise<Project | null> {
+    const projects = await this.getProjects();
+    return (
+      projects.find((p) => p.name.toLowerCase() === name.toLowerCase()) ?? null
+    );
+  }
+
+  /**
+   * Get all labels
+   */
+  async getLabels(): Promise<Label[]> {
+    try {
+      return await this.api.getLabels();
+    } catch (error) {
+      throw new Error(
+        `Failed to get labels: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  /**
+   * Create a label if it doesn't exist
+   */
+  async ensureLabel(name: string): Promise<Label> {
+    const labels = await this.getLabels();
+    const existing = labels.find(
+      (l) => l.name.toLowerCase() === name.toLowerCase(),
+    );
+
+    if (existing) {
+      return existing;
+    }
+
+    try {
+      return await this.api.addLabel({ name });
+    } catch (error) {
+      throw new Error(
+        `Failed to create label ${name}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  /**
+   * Test the API connection
+   */
+  async test(): Promise<boolean> {
+    try {
+      await this.getProjects();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+export { TodoistClient } from './client.js';
+export type { TodoistClientConfig } from './client.js';
+export {
+  md2doToTodoistPriority,
+  todoistToMd2doPriority,
+  extractTaskContent,
+  formatTaskContent,
+  md2doToTodoist,
+  todoistToMd2do,
+} from './mapper.js';
+export type { TodoistTaskParams, Md2doTaskUpdate } from './mapper.js';

package/src/mapper.ts

@@ -0,0 +1,225 @@
+import type { Task } from '@md2do/core';
+import type { Task as TodoistTask } from '@doist/todoist-api-typescript';
+
+/**
+ * Priority mapping between md2do and Todoist
+ * md2do: urgent (!!!) / high (!!) / normal (!) / low (none)
+ * Todoist: 4 / 3 / 2 / 1
+ */
+export function md2doToTodoistPriority(priority?: string): number {
+  switch (priority) {
+    case 'urgent':
+      return 4;
+    case 'high':
+      return 3;
+    case 'normal':
+      return 2;
+    case 'low':
+    default:
+      return 1;
+  }
+}
+
+export function todoistToMd2doPriority(priority: number): string | undefined {
+  switch (priority) {
+    case 4:
+      return 'urgent';
+    case 3:
+      return 'high';
+    case 2:
+      return 'normal';
+    case 1:
+      return 'low';
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * Extract task content without metadata for Todoist
+ * Removes: assignee, priority markers, tags, dates, todoist ID
+ */
+export function extractTaskContent(text: string): string {
+  return (
+    text
+      // Remove assignee @username
+      .replace(/@\w+/g, '')
+      // Remove priority markers
+      .replace(/!+/g, '')
+      // Remove tags
+      .replace(/#\w+/g, '')
+      // Remove dates in parentheses
+      .replace(/\(\d{4}-\d{2}-\d{2}\)/g, '')
+      // Remove Todoist ID
+      .replace(/\[todoist:\s*\d+\]/gi, '')
+      // Clean up extra whitespace
+      .replace(/\s+/g, ' ')
+      .trim()
+  );
+}
+
+/**
+ * Format Todoist task content for markdown
+ * Adds back assignee, priority, tags, and due date
+ */
+export function formatTaskContent(
+  content: string,
+  options: {
+    assignee?: string;
+    priority?: string;
+    tags?: string[];
+    due?: Date;
+    todoistId?: string;
+  },
+): string {
+  let result = content;
+
+  // Add assignee
+  if (options.assignee) {
+    result += ` @${options.assignee}`;
+  }
+
+  // Add priority markers
+  if (options.priority === 'urgent') {
+    result += ' !!!';
+  } else if (options.priority === 'high') {
+    result += ' !!';
+  } else if (options.priority === 'normal') {
+    result += ' !';
+  }
+
+  // Add tags
+  if (options.tags && options.tags.length > 0) {
+    result += ' ' + options.tags.map((tag) => `#${tag}`).join(' ');
+  }
+
+  // Add due date
+  if (options.due) {
+    // Format date in UTC to avoid timezone issues
+    const year = options.due.getUTCFullYear();
+    const month = String(options.due.getUTCMonth() + 1).padStart(2, '0');
+    const day = String(options.due.getUTCDate()).padStart(2, '0');
+    result += ` (${year}-${month}-${day})`;
+  }
+
+  // Add Todoist ID
+  if (options.todoistId) {
+    result += ` [todoist:${options.todoistId}]`;
+  }
+
+  return result;
+}
+
+/**
+ * Convert md2do task to Todoist task creation parameters
+ */
+export interface TodoistTaskParams {
+  content: string;
+  priority: number;
+  labels?: string[];
+  due_date?: string;
+  due_string?: string;
+  project_id?: string;
+}
+
+export function md2doToTodoist(
+  task: Task,
+  projectId?: string,
+): TodoistTaskParams {
+  const params: TodoistTaskParams = {
+    content: extractTaskContent(task.text),
+    priority: md2doToTodoistPriority(task.priority),
+  };
+
+  // Add labels from tags
+  if (task.tags && task.tags.length > 0) {
+    params.labels = task.tags;
+  }
+
+  // Add due date
+  if (task.dueDate) {
+    // Format date in UTC to avoid timezone issues
+    const year = task.dueDate.getUTCFullYear();
+    const month = String(task.dueDate.getUTCMonth() + 1).padStart(2, '0');
+    const day = String(task.dueDate.getUTCDate()).padStart(2, '0');
+    params.due_date = `${year}-${month}-${day}`;
+  }
+
+  // Add project ID
+  if (projectId) {
+    params.project_id = projectId;
+  }
+
+  return params;
+}
+
+/**
+ * Convert Todoist task to md2do task update data
+ */
+export interface Md2doTaskUpdate {
+  text: string;
+  completed: boolean;
+  todoistId: string;
+  priority?: string;
+  tags?: string[];
+  due?: Date;
+}
+
+export function todoistToMd2do(
+  todoistTask: TodoistTask,
+  assignee?: string,
+): Md2doTaskUpdate {
+  const priority = todoistToMd2doPriority(todoistTask.priority);
+  // Parse date string as UTC to avoid timezone issues
+  const due = todoistTask.due?.date
+    ? new Date(`${todoistTask.due.date}T00:00:00.000Z`)
+    : undefined;
+
+  // Build format options with only defined values
+  const formatOptions: {
+    assignee?: string;
+    priority?: string;
+    tags?: string[];
+    due?: Date;
+    todoistId?: string;
+  } = {
+    todoistId: todoistTask.id,
+  };
+
+  if (assignee !== undefined) {
+    formatOptions.assignee = assignee;
+  }
+
+  if (priority !== undefined) {
+    formatOptions.priority = priority;
+  }
+
+  if (todoistTask.labels.length > 0) {
+    formatOptions.tags = todoistTask.labels;
+  }
+
+  if (due !== undefined) {
+    formatOptions.due = due;
+  }
+
+  const update: Md2doTaskUpdate = {
+    text: formatTaskContent(todoistTask.content, formatOptions),
+    completed: todoistTask.isCompleted ?? false,
+    todoistId: todoistTask.id,
+  };
+
+  // Add optional properties only if they have values
+  if (priority !== undefined) {
+    update.priority = priority;
+  }
+
+  if (todoistTask.labels.length > 0) {
+    update.tags = todoistTask.labels;
+  }
+
+  if (due !== undefined) {
+    update.due = due;
+  }
+
+  return update;
+}

package/tests/mapper.test.ts

@@ -0,0 +1,283 @@
+import { describe, it, expect } from 'vitest';
+import {
+  md2doToTodoistPriority,
+  todoistToMd2doPriority,
+  extractTaskContent,
+  formatTaskContent,
+  md2doToTodoist,
+  todoistToMd2do,
+} from '../src/mapper.js';
+import type { Task } from '@md2do/core';
+import type { Task as TodoistTask } from '@doist/todoist-api-typescript';
+
+describe('md2doToTodoistPriority', () => {
+  it('should map urgent to 4', () => {
+    expect(md2doToTodoistPriority('urgent')).toBe(4);
+  });
+
+  it('should map high to 3', () => {
+    expect(md2doToTodoistPriority('high')).toBe(3);
+  });
+
+  it('should map normal to 2', () => {
+    expect(md2doToTodoistPriority('normal')).toBe(2);
+  });
+
+  it('should map low to 1', () => {
+    expect(md2doToTodoistPriority('low')).toBe(1);
+  });
+
+  it('should default to 1 for undefined', () => {
+    expect(md2doToTodoistPriority(undefined)).toBe(1);
+  });
+});
+
+describe('todoistToMd2doPriority', () => {
+  it('should map 4 to urgent', () => {
+    expect(todoistToMd2doPriority(4)).toBe('urgent');
+  });
+
+  it('should map 3 to high', () => {
+    expect(todoistToMd2doPriority(3)).toBe('high');
+  });
+
+  it('should map 2 to normal', () => {
+    expect(todoistToMd2doPriority(2)).toBe('normal');
+  });
+
+  it('should map 1 to low', () => {
+    expect(todoistToMd2doPriority(1)).toBe('low');
+  });
+
+  it('should return undefined for invalid priority', () => {
+    expect(todoistToMd2doPriority(0)).toBeUndefined();
+  });
+});
+
+describe('extractTaskContent', () => {
+  it('should remove assignee', () => {
+    const text = 'Fix bug @nick';
+    expect(extractTaskContent(text)).toBe('Fix bug');
+  });
+
+  it('should remove priority markers', () => {
+    const text = 'Fix bug !!!';
+    expect(extractTaskContent(text)).toBe('Fix bug');
+  });
+
+  it('should remove tags', () => {
+    const text = 'Fix bug #backend #urgent';
+    expect(extractTaskContent(text)).toBe('Fix bug');
+  });
+
+  it('should remove dates', () => {
+    const text = 'Fix bug (2026-01-20)';
+    expect(extractTaskContent(text)).toBe('Fix bug');
+  });
+
+  it('should remove Todoist ID', () => {
+    const text = 'Fix bug [todoist:123456]';
+    expect(extractTaskContent(text)).toBe('Fix bug');
+  });
+
+  it('should remove all metadata', () => {
+    const text = 'Fix bug @nick !!! #backend (2026-01-20) [todoist:123456]';
+    expect(extractTaskContent(text)).toBe('Fix bug');
+  });
+
+  it('should handle multiple spaces', () => {
+    const text = 'Fix   bug   @nick   !!!   #backend';
+    expect(extractTaskContent(text)).toBe('Fix bug');
+  });
+});
+
+describe('formatTaskContent', () => {
+  it('should format content with assignee', () => {
+    const result = formatTaskContent('Fix bug', { assignee: 'nick' });
+    expect(result).toBe('Fix bug @nick');
+  });
+
+  it('should format content with urgent priority', () => {
+    const result = formatTaskContent('Fix bug', { priority: 'urgent' });
+    expect(result).toBe('Fix bug !!!');
+  });
+
+  it('should format content with high priority', () => {
+    const result = formatTaskContent('Fix bug', { priority: 'high' });
+    expect(result).toBe('Fix bug !!');
+  });
+
+  it('should format content with normal priority', () => {
+    const result = formatTaskContent('Fix bug', { priority: 'normal' });
+    expect(result).toBe('Fix bug !');
+  });
+
+  it('should format content with tags', () => {
+    const result = formatTaskContent('Fix bug', {
+      tags: ['backend', 'urgent'],
+    });
+    expect(result).toBe('Fix bug #backend #urgent');
+  });
+
+  it('should format content with due date', () => {
+    const result = formatTaskContent('Fix bug', {
+      due: new Date('2026-01-20T00:00:00.000Z'),
+    });
+    expect(result).toBe('Fix bug (2026-01-20)');
+  });
+
+  it('should format content with Todoist ID', () => {
+    const result = formatTaskContent('Fix bug', { todoistId: '123456' });
+    expect(result).toBe('Fix bug [todoist:123456]');
+  });
+
+  it('should format content with all metadata', () => {
+    const result = formatTaskContent('Fix bug', {
+      assignee: 'nick',
+      priority: 'urgent',
+      tags: ['backend'],
+      due: new Date('2026-01-20T00:00:00.000Z'),
+      todoistId: '123456',
+    });
+    expect(result).toBe(
+      'Fix bug @nick !!! #backend (2026-01-20) [todoist:123456]',
+    );
+  });
+});
+
+describe('md2doToTodoist', () => {
+  it('should convert md2do task to Todoist params', () => {
+    const task: Task = {
+      id: 'test-id',
+      text: 'Fix bug @nick !!! #backend (2026-01-20)',
+      completed: false,
+      file: 'test.md',
+      line: 1,
+      tags: ['backend'],
+      assignee: 'nick',
+      priority: 'urgent',
+      dueDate: new Date('2026-01-20T00:00:00.000Z'),
+    };
+
+    const params = md2doToTodoist(task);
+
+    expect(params).toEqual({
+      content: 'Fix bug',
+      priority: 4,
+      labels: ['backend'],
+      due_date: '2026-01-20',
+    });
+  });
+
+  it('should include project ID if provided', () => {
+    const task: Task = {
+      id: 'test-id',
+      text: 'Fix bug',
+      completed: false,
+      file: 'test.md',
+      line: 1,
+      tags: [],
+    };
+
+    const params = md2doToTodoist(task, 'project-123');
+
+    expect(params.project_id).toBe('project-123');
+  });
+
+  it('should handle task without optional fields', () => {
+    const task: Task = {
+      id: 'test-id',
+      text: 'Fix bug',
+      completed: false,
+      file: 'test.md',
+      line: 1,
+      tags: [],
+    };
+
+    const params = md2doToTodoist(task);
+
+    expect(params).toEqual({
+      content: 'Fix bug',
+      priority: 1,
+    });
+  });
+});
+
+describe('todoistToMd2do', () => {
+  it('should convert Todoist task to md2do update', () => {
+    const todoistTask: TodoistTask = {
+      id: '123456',
+      order: 1,
+      content: 'Fix bug',
+      description: '',
+      priority: 4,
+      labels: ['backend'],
+      due: { date: '2026-01-20', isRecurring: false, string: '2026-01-20' },
+      isCompleted: false,
+      createdAt: '2026-01-18T10:00:00Z',
+      creatorId: 'user-id',
+      projectId: 'project-id',
+      commentCount: 0,
+      url: 'https://todoist.com/app/task/123456',
+    };
+
+    const update = todoistToMd2do(todoistTask, 'nick');
+
+    expect(update).toEqual({
+      text: 'Fix bug @nick !!! #backend (2026-01-20) [todoist:123456]',
+      completed: false,
+      priority: 'urgent',
+      tags: ['backend'],
+      due: new Date('2026-01-20T00:00:00.000Z'),
+      todoistId: '123456',
+    });
+  });
+
+  it('should handle completed task', () => {
+    const todoistTask: TodoistTask = {
+      id: '123456',
+      order: 1,
+      content: 'Fix bug',
+      description: '',
+      priority: 1,
+      labels: [],
+      isCompleted: true,
+      createdAt: '2026-01-18T10:00:00Z',
+      creatorId: 'user-id',
+      projectId: 'project-id',
+      commentCount: 0,
+      url: 'https://todoist.com/app/task/123456',
+    };
+
+    const update = todoistToMd2do(todoistTask);
+
+    expect(update.completed).toBe(true);
+    expect(update.text).toBe('Fix bug [todoist:123456]');
+  });
+
+  it('should handle task without optional fields', () => {
+    const todoistTask: TodoistTask = {
+      id: '123456',
+      order: 1,
+      content: 'Fix bug',
+      description: '',
+      priority: 1,
+      labels: [],
+      isCompleted: false,
+      createdAt: '2026-01-18T10:00:00Z',
+      creatorId: 'user-id',
+      projectId: 'project-id',
+      commentCount: 0,
+      url: 'https://todoist.com/app/task/123456',
+    };
+
+    const update = todoistToMd2do(todoistTask);
+
+    expect(update).toEqual({
+      text: 'Fix bug [todoist:123456]',
+      completed: false,
+      priority: 'low',
+      todoistId: '123456',
+    });
+  });
+});