@vibetasks/core 0.2.1 → 0.4.0

package/dist/index.d.ts

@@ -125,20 +125,39 @@ interface Tag {
     created_at?: string;
 }
 /**
- * Task status - simple 3-state flow for VibeTasks
+ * Task status - simple 3-state flow + archive for VibeTasks
  * - todo: Not started yet, waiting in backlog
  * - vibing: Currently in progress (actively working on it)
  * - done: Completed
+ * - archived: Archived (hidden from default views)
  */
-type TaskStatus = 'todo' | 'vibing' | 'done';
+type TaskStatus = 'todo' | 'vibing' | 'done' | 'archived';
+interface Subtask {
+    id: string;
+    title: string;
+    done: boolean;
+    notes?: string;
+}
+interface Attachment {
+    id: string;
+    task_id: string;
+    file_name: string;
+    file_type: string;
+    storage_path: string;
+    is_image?: boolean;
+    alt_text?: string;
+    ai_description?: string;
+}
 interface Task {
     id: string;
     user_id?: string;
     title: string;
+    description?: string;
     notes?: string;
     notes_format?: 'html' | 'markdown';
     completed?: boolean;
     completed_at?: string;
+    archived_at?: string;
     due_date?: string;
     start_date?: string;
     duration_minutes?: number;
@@ -151,8 +170,9 @@ interface Task {
     created_at?: string;
     updated_at?: string;
     tags?: Tag[];
-    attachments?: any[];
+    attachments?: Attachment[];
     subtasks?: Task[];
+    subtasks_json?: Subtask[];
     status?: TaskStatus;
     project_tag?: string;
     created_by?: 'ai' | 'human';
@@ -170,22 +190,150 @@ declare class TaskOperations {
      * Create TaskOperations from AuthManager
      */
     static fromAuthManager(authManager: AuthManager): Promise<TaskOperations>;
-    getTasks(filter?: TaskFilter): Promise<Task[]>;
+    getTasks(filter?: TaskFilter, includeArchived?: boolean): Promise<Task[]>;
     getTask(taskId: string): Promise<Task>;
     createTask(task: Partial<Task>): Promise<Task>;
     updateTask(taskId: string, updates: Partial<Task>): Promise<Task>;
     deleteTask(taskId: string): Promise<void>;
     completeTask(taskId: string): Promise<Task>;
     uncompleteTask(taskId: string): Promise<Task>;
+    /**
+     * Archive a task - moves it to archived status
+     * Typically used for completed tasks you want to hide from views
+     */
+    archiveTask(taskId: string): Promise<Task>;
+    /**
+     * Unarchive a task - restores it to its previous state (done by default)
+     */
+    unarchiveTask(taskId: string, restoreStatus?: TaskStatus): Promise<Task>;
+    /**
+     * Get all archived tasks
+     */
+    getArchivedTasks(limit?: number): Promise<Task[]>;
     getTags(): Promise<Tag[]>;
     createTag(name: string, color?: string): Promise<Tag>;
     linkTaskTags(taskId: string, tagIds: string[]): Promise<void>;
     unlinkAllTaskTags(taskId: string): Promise<void>;
-    searchTasks(query: string, limit?: number): Promise<Task[]>;
+    searchTasks(query: string, limit?: number, includeArchived?: boolean): Promise<Task[]>;
     /**
      * Find tag by name (case-insensitive), create if doesn't exist
      */
     findOrCreateTag(name: string, color?: string): Promise<Tag>;
+    /**
+     * Get a signed URL for an attachment (valid for 1 hour)
+     */
+    getAttachmentUrl(storagePath: string): Promise<string>;
+    /**
+     * Get all attachments for a task with signed URLs
+     */
+    getTaskAttachments(taskId: string): Promise<(Attachment & {
+        url: string;
+    })[]>;
 }
 
-export { AuthManager, ConfigManager, type SupabaseConfig, type Tag, type Task, type TaskFilter, type TaskFlowConfig, TaskOperations, type TaskPriority, type TaskStatus, createSupabaseClient, createSupabaseClientFromEnv };
+/**
+ * Claude Code TodoWrite Sync
+ *
+ * This module provides synchronization between Claude's TodoWrite state
+ * and VibeTasks task statuses.
+ *
+ * Status mapping:
+ *   Claude "pending"     -> VibeTasks "todo"
+ *   Claude "in_progress" -> VibeTasks "vibing"
+ *   Claude "completed"   -> VibeTasks "done"
+ */
+
+/**
+ * Claude Code TodoWrite item structure
+ */
+interface ClaudeTodoItem {
+    /** The task description/content */
+    content: string;
+    /** Current status: pending, in_progress, or completed */
+    status: 'pending' | 'in_progress' | 'completed';
+    /** Active form description (used during in_progress) */
+    activeForm?: string;
+}
+/**
+ * Result of syncing a single todo item
+ */
+interface SyncResult {
+    /** The Claude todo content */
+    content: string;
+    /** Whether a matching VibeTasks task was found */
+    matched: boolean;
+    /** The VibeTasks task ID if matched */
+    taskId?: string;
+    /** The action taken */
+    action: 'created' | 'updated' | 'skipped' | 'not_found';
+    /** Previous status (if updated) */
+    previousStatus?: TaskStatus;
+    /** New status (if updated) */
+    newStatus?: TaskStatus;
+    /** Error message if any */
+    error?: string;
+}
+/**
+ * Result of syncing all todos
+ */
+interface SyncAllResult {
+    /** Whether the overall sync was successful */
+    success: boolean;
+    /** Number of todos processed */
+    processed: number;
+    /** Number of todos synced successfully */
+    synced: number;
+    /** Number of todos that failed to sync */
+    failed: number;
+    /** Individual sync results */
+    results: SyncResult[];
+}
+/**
+ * Options for the sync operation
+ */
+interface SyncOptions {
+    /** Create new tasks for unmatched todos (default: false) */
+    createMissing?: boolean;
+    /** Project tag to use for created tasks */
+    projectTag?: string;
+    /** Minimum similarity score for matching (0-1, default: 0.6) */
+    matchThreshold?: number;
+    /** Whether to sync 'pending' todos as 'todo' status (default: true) */
+    syncPending?: boolean;
+}
+/**
+ * Claude Sync class for managing TodoWrite synchronization
+ */
+declare class ClaudeSync {
+    private taskOps;
+    constructor(taskOps: TaskOperations);
+    /**
+     * Sync a single Claude todo item with VibeTasks
+     */
+    syncTodo(todo: ClaudeTodoItem, existingTasks?: Task[], options?: SyncOptions): Promise<SyncResult>;
+    /**
+     * Sync all Claude todos with VibeTasks
+     */
+    syncAllTodos(todos: ClaudeTodoItem[], options?: SyncOptions): Promise<SyncAllResult>;
+    /**
+     * Get current vibing tasks (for comparison with Claude's in_progress)
+     */
+    getVibingTasks(): Promise<Task[]>;
+    /**
+     * Auto-start vibing on a task when Claude marks it as in_progress
+     */
+    startVibing(taskId: string): Promise<Task>;
+    /**
+     * Complete a task when Claude marks it as completed
+     */
+    completeTask(taskId: string): Promise<Task>;
+}
+/**
+ * MCP Tool: sync_claude_todos
+ *
+ * This function is designed to be called as an MCP tool.
+ * It accepts Claude's current todo list and syncs it with VibeTasks.
+ */
+declare function syncClaudeTodos(taskOps: TaskOperations, todos: ClaudeTodoItem[], options?: SyncOptions): Promise<SyncAllResult>;
+
+export { AuthManager, ClaudeSync, type ClaudeTodoItem, ConfigManager, type SupabaseConfig, type SyncAllResult, type SyncOptions, type SyncResult, type Tag, type Task, type TaskFilter, type TaskFlowConfig, TaskOperations, type TaskPriority, type TaskStatus, createSupabaseClient, createSupabaseClientFromEnv, syncClaudeTodos };

package/dist/index.js

@@ -287,11 +287,14 @@ var TaskOperations = class _TaskOperations {
   // ============================================
   // TASK CRUD OPERATIONS
   // ============================================
-  async getTasks(filter = "all") {
+  async getTasks(filter = "all", includeArchived = false) {
     let query = this.supabase.from("tasks").select(`
         *,
         tags:task_tags(tag:tags(*))
       `).is("parent_task_id", null).order("position", { ascending: true });
+    if (!includeArchived) {
+      query = query.neq("status", "archived");
+    }
     if (filter === "today") {
       const today = /* @__PURE__ */ new Date();
       today.setHours(0, 0, 0, 0);
@@ -318,12 +321,16 @@ var TaskOperations = class _TaskOperations {
   async getTask(taskId) {
     const { data, error } = await this.supabase.from("tasks").select(`
         *,
-        tags:task_tags(tag:tags(*))
+        tags:task_tags(tag:tags(*)),
+        attachments:task_attachments(*)
       `).eq("id", taskId).single();
     if (error) throw error;
     return {
       ...data,
-      tags: data.tags?.map((t) => t.tag).filter(Boolean) || []
+      tags: data.tags?.map((t) => t.tag).filter(Boolean) || [],
+      attachments: data.attachments || [],
+      subtasks_json: data.subtasks || []
+      // DB column is 'subtasks', maps to subtasks_json
     };
   }
   async createTask(task) {
@@ -332,6 +339,7 @@ var TaskOperations = class _TaskOperations {
     const { data, error } = await this.supabase.from("tasks").insert({
       user_id: user.id,
       title: task.title,
+      description: task.description,
       notes: task.notes,
       notes_format: task.notes_format || "markdown",
       due_date: task.due_date,
@@ -343,6 +351,8 @@ var TaskOperations = class _TaskOperations {
       priority: task.priority || "none",
       parent_task_id: task.parent_task_id,
       position: task.position || 0,
+      subtasks: task.subtasks_json || [],
+      // Inline subtasks as JSON
       // VibeTasks-specific fields
       status: task.status || "todo",
       project_tag: task.project_tag,
@@ -359,6 +369,7 @@ var TaskOperations = class _TaskOperations {
   async updateTask(taskId, updates) {
     const updateData = {};
     if (updates.title !== void 0) updateData.title = updates.title;
+    if (updates.description !== void 0) updateData.description = updates.description;
     if (updates.notes !== void 0) updateData.notes = updates.notes;
     if (updates.notes_format !== void 0) updateData.notes_format = updates.notes_format;
     if (updates.completed !== void 0) {
@@ -373,6 +384,7 @@ var TaskOperations = class _TaskOperations {
     if (updates.recurrence_end !== void 0) updateData.recurrence_end = updates.recurrence_end;
     if (updates.priority !== void 0) updateData.priority = updates.priority;
     if (updates.position !== void 0) updateData.position = updates.position;
+    if (updates.subtasks_json !== void 0) updateData.subtasks = updates.subtasks_json;
     if (updates.status !== void 0) updateData.status = updates.status;
     if (updates.project_tag !== void 0) updateData.project_tag = updates.project_tag;
     if (updates.created_by !== void 0) updateData.created_by = updates.created_by;
@@ -409,6 +421,46 @@ var TaskOperations = class _TaskOperations {
     return data;
   }
   // ============================================
+  // ARCHIVE OPERATIONS
+  // ============================================
+  /**
+   * Archive a task - moves it to archived status
+   * Typically used for completed tasks you want to hide from views
+   */
+  async archiveTask(taskId) {
+    const { data, error } = await this.supabase.from("tasks").update({
+      status: "archived",
+      archived_at: (/* @__PURE__ */ new Date()).toISOString()
+    }).eq("id", taskId).select().single();
+    if (error) throw error;
+    return data;
+  }
+  /**
+   * Unarchive a task - restores it to its previous state (done by default)
+   */
+  async unarchiveTask(taskId, restoreStatus = "done") {
+    const { data, error } = await this.supabase.from("tasks").update({
+      status: restoreStatus,
+      archived_at: null
+    }).eq("id", taskId).select().single();
+    if (error) throw error;
+    return data;
+  }
+  /**
+   * Get all archived tasks
+   */
+  async getArchivedTasks(limit = 50) {
+    const { data, error } = await this.supabase.from("tasks").select(`
+        *,
+        tags:task_tags(tag:tags(*))
+      `).eq("status", "archived").is("parent_task_id", null).order("archived_at", { ascending: false }).limit(limit);
+    if (error) throw error;
+    return (data || []).map((task) => ({
+      ...task,
+      tags: task.tags?.map((t) => t.tag).filter(Boolean) || []
+    }));
+  }
+  // ============================================
   // TAG OPERATIONS
   // ============================================
   async getTags() {
@@ -435,11 +487,15 @@ var TaskOperations = class _TaskOperations {
   // ============================================
   // SEARCH & UTILITY
   // ============================================
-  async searchTasks(query, limit = 20) {
-    const { data, error } = await this.supabase.from("tasks").select(`
+  async searchTasks(query, limit = 20, includeArchived = false) {
+    let dbQuery = this.supabase.from("tasks").select(`
         *,
         tags:task_tags(tag:tags(*))
       `).ilike("title", `%${query}%`).is("parent_task_id", null).eq("completed", false).order("position", { ascending: true }).limit(limit);
+    if (!includeArchived) {
+      dbQuery = dbQuery.neq("status", "archived");
+    }
+    const { data, error } = await dbQuery;
     if (error) throw error;
     return (data || []).map((task) => ({
       ...task,
@@ -457,11 +513,242 @@ var TaskOperations = class _TaskOperations {
     }
     return await this.createTag(name, color);
   }
+  // ============================================
+  // ATTACHMENT OPERATIONS
+  // ============================================
+  /**
+   * Get a signed URL for an attachment (valid for 1 hour)
+   */
+  async getAttachmentUrl(storagePath) {
+    const { data, error } = await this.supabase.storage.from("task-attachments").createSignedUrl(storagePath, 3600);
+    if (error) throw error;
+    return data.signedUrl;
+  }
+  /**
+   * Get all attachments for a task with signed URLs
+   */
+  async getTaskAttachments(taskId) {
+    const { data, error } = await this.supabase.from("task_attachments").select("*").eq("task_id", taskId);
+    if (error) throw error;
+    const attachmentsWithUrls = await Promise.all(
+      (data || []).map(async (attachment) => {
+        const url = await this.getAttachmentUrl(attachment.storage_path);
+        return { ...attachment, url };
+      })
+    );
+    return attachmentsWithUrls;
+  }
 };
+
+// src/claude-sync.ts
+function mapStatus(claudeStatus) {
+  switch (claudeStatus) {
+    case "pending":
+      return "todo";
+    case "in_progress":
+      return "vibing";
+    case "completed":
+      return "done";
+    default:
+      return "todo";
+  }
+}
+function calculateSimilarity(str1, str2) {
+  const s1 = str1.toLowerCase().trim();
+  const s2 = str2.toLowerCase().trim();
+  if (s1 === s2) return 1;
+  if (s1.length === 0 || s2.length === 0) return 0;
+  if (s1.includes(s2) || s2.includes(s1)) {
+    return 0.8;
+  }
+  const words1 = new Set(s1.split(/\s+/));
+  const words2 = new Set(s2.split(/\s+/));
+  let commonWords = 0;
+  for (const word of words1) {
+    if (words2.has(word)) {
+      commonWords++;
+    }
+  }
+  const totalWords = Math.max(words1.size, words2.size);
+  if (totalWords === 0) return 0;
+  return commonWords / totalWords;
+}
+function findBestMatch(todoContent, tasks, threshold = 0.6) {
+  let bestMatch = null;
+  for (const task of tasks) {
+    const similarity = calculateSimilarity(todoContent, task.title);
+    if (similarity >= threshold) {
+      if (!bestMatch || similarity > bestMatch.similarity) {
+        bestMatch = { task, similarity };
+      }
+    }
+    if (task.context_notes) {
+      const noteSimilarity = calculateSimilarity(todoContent, task.context_notes);
+      if (noteSimilarity >= threshold && noteSimilarity > (bestMatch?.similarity || 0)) {
+        bestMatch = { task, similarity: noteSimilarity };
+      }
+    }
+  }
+  return bestMatch;
+}
+var ClaudeSync = class {
+  taskOps;
+  constructor(taskOps) {
+    this.taskOps = taskOps;
+  }
+  /**
+   * Sync a single Claude todo item with VibeTasks
+   */
+  async syncTodo(todo, existingTasks, options = {}) {
+    const {
+      createMissing = false,
+      projectTag,
+      matchThreshold = 0.6,
+      syncPending = true
+    } = options;
+    try {
+      if (todo.status === "pending" && !syncPending) {
+        return {
+          content: todo.content,
+          matched: false,
+          action: "skipped"
+        };
+      }
+      const tasks = existingTasks || await this.taskOps.getTasks("all");
+      const match = findBestMatch(todo.content, tasks, matchThreshold);
+      if (match) {
+        const vibeStatus = mapStatus(todo.status);
+        const currentStatus = match.task.status || "todo";
+        if (currentStatus !== vibeStatus) {
+          if (vibeStatus === "done" && !match.task.completed) {
+            await this.taskOps.completeTask(match.task.id);
+          } else {
+            await this.taskOps.updateTask(match.task.id, {
+              status: vibeStatus,
+              completed: vibeStatus === "done"
+            });
+          }
+          return {
+            content: todo.content,
+            matched: true,
+            taskId: match.task.id,
+            action: "updated",
+            previousStatus: currentStatus,
+            newStatus: vibeStatus
+          };
+        }
+        return {
+          content: todo.content,
+          matched: true,
+          taskId: match.task.id,
+          action: "skipped"
+        };
+      }
+      if (createMissing) {
+        const vibeStatus = mapStatus(todo.status);
+        const newTask = await this.taskOps.createTask({
+          title: todo.content,
+          status: vibeStatus,
+          project_tag: projectTag,
+          created_by: "ai",
+          context_notes: todo.activeForm ? `Started: ${todo.activeForm}` : void 0,
+          completed: vibeStatus === "done"
+        });
+        return {
+          content: todo.content,
+          matched: false,
+          taskId: newTask.id,
+          action: "created",
+          newStatus: vibeStatus
+        };
+      }
+      return {
+        content: todo.content,
+        matched: false,
+        action: "not_found"
+      };
+    } catch (error) {
+      return {
+        content: todo.content,
+        matched: false,
+        action: "skipped",
+        error: error.message
+      };
+    }
+  }
+  /**
+   * Sync all Claude todos with VibeTasks
+   */
+  async syncAllTodos(todos, options = {}) {
+    const results = [];
+    let synced = 0;
+    let failed = 0;
+    try {
+      const tasks = await this.taskOps.getTasks("all");
+      for (const todo of todos) {
+        const result = await this.syncTodo(todo, tasks, options);
+        results.push(result);
+        if (result.action === "updated" || result.action === "created") {
+          synced++;
+        } else if (result.error) {
+          failed++;
+        }
+      }
+      return {
+        success: failed === 0,
+        processed: todos.length,
+        synced,
+        failed,
+        results
+      };
+    } catch (error) {
+      return {
+        success: false,
+        processed: 0,
+        synced: 0,
+        failed: todos.length,
+        results: [{
+          content: "All todos",
+          matched: false,
+          action: "skipped",
+          error: error.message
+        }]
+      };
+    }
+  }
+  /**
+   * Get current vibing tasks (for comparison with Claude's in_progress)
+   */
+  async getVibingTasks() {
+    const allTasks = await this.taskOps.getTasks("all");
+    return allTasks.filter((t) => t.status === "vibing" && !t.completed);
+  }
+  /**
+   * Auto-start vibing on a task when Claude marks it as in_progress
+   */
+  async startVibing(taskId) {
+    return await this.taskOps.updateTask(taskId, {
+      status: "vibing",
+      completed: false
+    });
+  }
+  /**
+   * Complete a task when Claude marks it as completed
+   */
+  async completeTask(taskId) {
+    return await this.taskOps.completeTask(taskId);
+  }
+};
+async function syncClaudeTodos(taskOps, todos, options = {}) {
+  const sync = new ClaudeSync(taskOps);
+  return await sync.syncAllTodos(todos, options);
+}
 export {
   AuthManager,
+  ClaudeSync,
   ConfigManager,
   TaskOperations,
   createSupabaseClient,
-  createSupabaseClientFromEnv
+  createSupabaseClientFromEnv,
+  syncClaudeTodos
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibetasks/core",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "Shared core logic for VibeTasks MCP server and CLI - authentication, task operations, and config management",
   "author": "Vyas",
   "license": "MIT",