@vibetasks/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,179 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+
+interface TaskFlowConfig {
+    supabase_url?: string;
+    supabase_key?: string;
+    default_priority?: 'none' | 'low' | 'medium' | 'high';
+    list_limit?: number;
+    [key: string]: any;
+}
+/**
+ * Manages TaskFlow configuration stored in ~/.config/taskflow/config.json
+ */
+declare class ConfigManager {
+    private configDir;
+    private configPath;
+    constructor();
+    /**
+     * Ensure the config directory exists
+     */
+    ensureConfigDir(): Promise<void>;
+    /**
+     * Get the full configuration object
+     */
+    getConfig(): Promise<TaskFlowConfig>;
+    /**
+     * Set a configuration value
+     */
+    setConfig(key: string, value: any): Promise<void>;
+    /**
+     * Get a single configuration value
+     */
+    get(key: string): Promise<any>;
+    /**
+     * Delete a configuration value
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Clear all configuration
+     */
+    clear(): Promise<void>;
+    /**
+     * Get the config file path (useful for debugging)
+     */
+    getConfigPath(): string;
+}
+
+/**
+ * Manages authentication tokens with secure storage
+ * Uses system keychain (keytar) when available, falls back to config file
+ */
+declare class AuthManager {
+    private configManager;
+    private keytar;
+    private useKeytar;
+    constructor();
+    /**
+     * Initialize keytar (system keychain) if available
+     */
+    private initKeytar;
+    /**
+     * Get the access token
+     */
+    getAccessToken(): Promise<string | null>;
+    /**
+     * Set the access token
+     */
+    setAccessToken(token: string): Promise<void>;
+    /**
+     * Get the refresh token
+     */
+    getRefreshToken(): Promise<string | null>;
+    /**
+     * Set the refresh token
+     */
+    setRefreshToken(token: string): Promise<void>;
+    /**
+     * Delete all stored tokens
+     */
+    clearTokens(): Promise<void>;
+    /**
+     * Get a config value (pass-through to ConfigManager)
+     */
+    getConfig(key: string): Promise<any>;
+    /**
+     * Set a config value (pass-through to ConfigManager)
+     */
+    setConfig(key: string, value: any): Promise<void>;
+    /**
+     * Check if user is authenticated (has access token)
+     */
+    isAuthenticated(): Promise<boolean>;
+    /**
+     * Get storage method being used
+     */
+    getStorageMethod(): 'keychain' | 'config-file';
+}
+
+interface SupabaseConfig {
+    supabaseUrl: string;
+    supabaseKey: string;
+    accessToken?: string;
+}
+/**
+ * Create a Supabase client with the provided configuration
+ *
+ * @param config - Supabase configuration including URL, key, and optional access token
+ * @returns Configured Supabase client
+ */
+declare function createSupabaseClient(config: SupabaseConfig): SupabaseClient;
+/**
+ * Create a Supabase client from environment variables
+ *
+ * @returns Configured Supabase client
+ * @throws Error if environment variables are not set
+ */
+declare function createSupabaseClientFromEnv(): SupabaseClient;
+
+type TaskFilter = 'all' | 'today' | 'upcoming' | 'completed';
+type TaskPriority = 'none' | 'low' | 'medium' | 'high';
+interface Tag {
+    id: string;
+    user_id?: string;
+    name: string;
+    color: string;
+    created_at?: string;
+}
+interface Task {
+    id: string;
+    user_id?: string;
+    title: string;
+    notes?: string;
+    notes_format?: 'html' | 'markdown';
+    completed?: boolean;
+    completed_at?: string;
+    due_date?: string;
+    start_date?: string;
+    duration_minutes?: number;
+    scheduled_time?: string;
+    recurrence_rule?: string;
+    recurrence_end?: string;
+    priority?: TaskPriority;
+    parent_task_id?: string;
+    position?: number;
+    created_at?: string;
+    updated_at?: string;
+    tags?: Tag[];
+    attachments?: any[];
+    subtasks?: Task[];
+}
+/**
+ * TaskOperations class provides a high-level API for task management
+ * Wraps the existing task-service.ts functionality with authentication and configuration
+ */
+declare class TaskOperations {
+    private supabase;
+    constructor(supabase: SupabaseClient);
+    /**
+     * Create TaskOperations from AuthManager
+     */
+    static fromAuthManager(authManager: AuthManager): Promise<TaskOperations>;
+    getTasks(filter?: TaskFilter): 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>;
+    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[]>;
+    /**
+     * Find tag by name (case-insensitive), create if doesn't exist
+     */
+    findOrCreateTag(name: string, color?: string): Promise<Tag>;
+}
+
+export { AuthManager, ConfigManager, type SupabaseConfig, type Tag, type Task, type TaskFilter, type TaskFlowConfig, TaskOperations, type TaskPriority, createSupabaseClient, createSupabaseClientFromEnv };

package/dist/index.js

@@ -0,0 +1,456 @@
+// src/config-manager.ts
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+var ConfigManager = class {
+  configDir;
+  configPath;
+  constructor() {
+    const configHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+    this.configDir = path.join(configHome, "taskflow");
+    this.configPath = path.join(this.configDir, "config.json");
+  }
+  /**
+   * Ensure the config directory exists
+   */
+  async ensureConfigDir() {
+    try {
+      await fs.mkdir(this.configDir, { recursive: true });
+    } catch (error) {
+      throw new Error(`Failed to create config directory: ${error.message}`);
+    }
+  }
+  /**
+   * Get the full configuration object
+   */
+  async getConfig() {
+    try {
+      const data = await fs.readFile(this.configPath, "utf-8");
+      return JSON.parse(data);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return {};
+      }
+      throw new Error(`Failed to read config: ${error.message}`);
+    }
+  }
+  /**
+   * Set a configuration value
+   */
+  async setConfig(key, value) {
+    await this.ensureConfigDir();
+    const config = await this.getConfig();
+    config[key] = value;
+    try {
+      await fs.writeFile(this.configPath, JSON.stringify(config, null, 2), "utf-8");
+    } catch (error) {
+      throw new Error(`Failed to write config: ${error.message}`);
+    }
+  }
+  /**
+   * Get a single configuration value
+   */
+  async get(key) {
+    const config = await this.getConfig();
+    return config[key];
+  }
+  /**
+   * Delete a configuration value
+   */
+  async delete(key) {
+    await this.ensureConfigDir();
+    const config = await this.getConfig();
+    delete config[key];
+    try {
+      await fs.writeFile(this.configPath, JSON.stringify(config, null, 2), "utf-8");
+    } catch (error) {
+      throw new Error(`Failed to write config: ${error.message}`);
+    }
+  }
+  /**
+   * Clear all configuration
+   */
+  async clear() {
+    try {
+      await fs.unlink(this.configPath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw new Error(`Failed to clear config: ${error.message}`);
+      }
+    }
+  }
+  /**
+   * Get the config file path (useful for debugging)
+   */
+  getConfigPath() {
+    return this.configPath;
+  }
+};
+
+// src/auth-manager.ts
+var SERVICE_NAME = "taskflow-cli";
+var ACCESS_TOKEN_ACCOUNT = "access-token";
+var REFRESH_TOKEN_ACCOUNT = "refresh-token";
+var AuthManager = class {
+  configManager;
+  keytar = null;
+  useKeytar = false;
+  constructor() {
+    this.configManager = new ConfigManager();
+    this.initKeytar();
+  }
+  /**
+   * Initialize keytar (system keychain) if available
+   */
+  async initKeytar() {
+    try {
+      this.keytar = await import("keytar");
+      this.useKeytar = true;
+    } catch (error) {
+      this.useKeytar = false;
+    }
+  }
+  /**
+   * Get the access token
+   */
+  async getAccessToken() {
+    if (this.keytar === null && process.platform !== "linux") {
+      await this.initKeytar();
+    }
+    if (this.useKeytar && this.keytar) {
+      try {
+        const token = await this.keytar.getPassword(SERVICE_NAME, ACCESS_TOKEN_ACCOUNT);
+        if (token) return token;
+      } catch (error) {
+      }
+    }
+    return await this.configManager.get("access_token");
+  }
+  /**
+   * Set the access token
+   */
+  async setAccessToken(token) {
+    if (this.keytar === null && process.platform !== "linux") {
+      await this.initKeytar();
+    }
+    if (this.useKeytar && this.keytar) {
+      try {
+        await this.keytar.setPassword(SERVICE_NAME, ACCESS_TOKEN_ACCOUNT, token);
+        return;
+      } catch (error) {
+      }
+    }
+    await this.configManager.setConfig("access_token", token);
+  }
+  /**
+   * Get the refresh token
+   */
+  async getRefreshToken() {
+    if (this.keytar === null && process.platform !== "linux") {
+      await this.initKeytar();
+    }
+    if (this.useKeytar && this.keytar) {
+      try {
+        const token = await this.keytar.getPassword(SERVICE_NAME, REFRESH_TOKEN_ACCOUNT);
+        if (token) return token;
+      } catch (error) {
+      }
+    }
+    return await this.configManager.get("refresh_token");
+  }
+  /**
+   * Set the refresh token
+   */
+  async setRefreshToken(token) {
+    if (this.keytar === null && process.platform !== "linux") {
+      await this.initKeytar();
+    }
+    if (this.useKeytar && this.keytar) {
+      try {
+        await this.keytar.setPassword(SERVICE_NAME, REFRESH_TOKEN_ACCOUNT, token);
+        return;
+      } catch (error) {
+      }
+    }
+    await this.configManager.setConfig("refresh_token", token);
+  }
+  /**
+   * Delete all stored tokens
+   */
+  async clearTokens() {
+    if (this.keytar === null && process.platform !== "linux") {
+      await this.initKeytar();
+    }
+    if (this.useKeytar && this.keytar) {
+      try {
+        await this.keytar.deletePassword(SERVICE_NAME, ACCESS_TOKEN_ACCOUNT);
+        await this.keytar.deletePassword(SERVICE_NAME, REFRESH_TOKEN_ACCOUNT);
+      } catch (error) {
+      }
+    }
+    await this.configManager.delete("access_token");
+    await this.configManager.delete("refresh_token");
+  }
+  /**
+   * Get a config value (pass-through to ConfigManager)
+   */
+  async getConfig(key) {
+    return await this.configManager.get(key);
+  }
+  /**
+   * Set a config value (pass-through to ConfigManager)
+   */
+  async setConfig(key, value) {
+    await this.configManager.setConfig(key, value);
+  }
+  /**
+   * Check if user is authenticated (has access token)
+   */
+  async isAuthenticated() {
+    const token = await this.getAccessToken();
+    return token !== null && token !== void 0 && token.length > 0;
+  }
+  /**
+   * Get storage method being used
+   */
+  getStorageMethod() {
+    return this.useKeytar ? "keychain" : "config-file";
+  }
+};
+
+// src/supabase-client.ts
+import { createClient } from "@supabase/supabase-js";
+function createSupabaseClient(config) {
+  const { supabaseUrl, supabaseKey, accessToken } = config;
+  if (!supabaseUrl || !supabaseKey) {
+    throw new Error("Supabase URL and key are required");
+  }
+  const client = createClient(supabaseUrl, supabaseKey, {
+    auth: {
+      persistSession: false,
+      // CLI/MCP don't need session persistence
+      autoRefreshToken: false
+      // We'll handle refresh manually if needed
+    },
+    global: accessToken ? {
+      headers: {
+        Authorization: `Bearer ${accessToken}`
+      }
+    } : void 0
+  });
+  return client;
+}
+function createSupabaseClientFromEnv() {
+  const supabaseUrl = process.env.TASKFLOW_SUPABASE_URL || process.env.SUPABASE_URL;
+  const supabaseKey = process.env.TASKFLOW_SUPABASE_KEY || process.env.SUPABASE_KEY || process.env.SUPABASE_ANON_KEY;
+  const accessToken = process.env.TASKFLOW_ACCESS_TOKEN;
+  if (!supabaseUrl || !supabaseKey) {
+    throw new Error(
+      "Supabase configuration not found in environment variables. Set TASKFLOW_SUPABASE_URL and TASKFLOW_SUPABASE_KEY, or run: taskflow login"
+    );
+  }
+  return createSupabaseClient({
+    supabaseUrl,
+    supabaseKey,
+    accessToken
+  });
+}
+
+// src/task-operations.ts
+var TaskOperations = class _TaskOperations {
+  supabase;
+  constructor(supabase) {
+    this.supabase = supabase;
+  }
+  /**
+   * Create TaskOperations from AuthManager
+   */
+  static async fromAuthManager(authManager) {
+    const supabaseUrl = await authManager.getConfig("supabase_url");
+    const supabaseKey = await authManager.getConfig("supabase_key");
+    const accessToken = await authManager.getAccessToken();
+    if (!supabaseUrl || !supabaseKey) {
+      throw new Error(
+        "Supabase configuration not found. Run: taskflow login"
+      );
+    }
+    if (!accessToken) {
+      throw new Error("Not authenticated. Run: taskflow login");
+    }
+    const supabase = createSupabaseClient({
+      supabaseUrl,
+      supabaseKey,
+      accessToken
+    });
+    return new _TaskOperations(supabase);
+  }
+  // ============================================
+  // TASK CRUD OPERATIONS
+  // ============================================
+  async getTasks(filter = "all") {
+    let query = this.supabase.from("tasks").select(`
+        *,
+        tags:task_tags(tag:tags(*))
+      `).is("parent_task_id", null).order("position", { ascending: true });
+    if (filter === "today") {
+      const today = /* @__PURE__ */ new Date();
+      today.setHours(0, 0, 0, 0);
+      const tomorrow = new Date(today);
+      tomorrow.setDate(tomorrow.getDate() + 1);
+      query = query.gte("due_date", today.toISOString()).lt("due_date", tomorrow.toISOString()).eq("completed", false);
+    } else if (filter === "upcoming") {
+      const tomorrow = /* @__PURE__ */ new Date();
+      tomorrow.setDate(tomorrow.getDate() + 1);
+      tomorrow.setHours(0, 0, 0, 0);
+      query = query.gte("due_date", tomorrow.toISOString()).eq("completed", false);
+    } else if (filter === "completed") {
+      query = query.eq("completed", true).order("completed_at", { ascending: false });
+    } else {
+      query = query.eq("completed", false);
+    }
+    const { data, error } = await query;
+    if (error) throw error;
+    return (data || []).map((task) => ({
+      ...task,
+      tags: task.tags?.map((t) => t.tag).filter(Boolean) || []
+    }));
+  }
+  async getTask(taskId) {
+    const { data, error } = await this.supabase.from("tasks").select(`
+        *,
+        tags:task_tags(tag:tags(*))
+      `).eq("id", taskId).single();
+    if (error) throw error;
+    return {
+      ...data,
+      tags: data.tags?.map((t) => t.tag).filter(Boolean) || []
+    };
+  }
+  async createTask(task) {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) throw new Error("Not authenticated");
+    const { data, error } = await this.supabase.from("tasks").insert({
+      user_id: user.id,
+      title: task.title,
+      notes: task.notes,
+      notes_format: task.notes_format || "markdown",
+      due_date: task.due_date,
+      start_date: task.start_date,
+      duration_minutes: task.duration_minutes,
+      scheduled_time: task.scheduled_time,
+      recurrence_rule: task.recurrence_rule,
+      recurrence_end: task.recurrence_end,
+      priority: task.priority || "none",
+      parent_task_id: task.parent_task_id,
+      position: task.position || 0
+    }).select().single();
+    if (error) throw error;
+    if (task.tags && task.tags.length > 0) {
+      await this.linkTaskTags(data.id, task.tags.map((t) => t.id));
+    }
+    return data;
+  }
+  async updateTask(taskId, updates) {
+    const updateData = {};
+    if (updates.title !== void 0) updateData.title = updates.title;
+    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) {
+      updateData.completed = updates.completed;
+      updateData.completed_at = updates.completed ? (/* @__PURE__ */ new Date()).toISOString() : null;
+    }
+    if (updates.due_date !== void 0) updateData.due_date = updates.due_date;
+    if (updates.start_date !== void 0) updateData.start_date = updates.start_date;
+    if (updates.duration_minutes !== void 0) updateData.duration_minutes = updates.duration_minutes;
+    if (updates.scheduled_time !== void 0) updateData.scheduled_time = updates.scheduled_time;
+    if (updates.recurrence_rule !== void 0) updateData.recurrence_rule = updates.recurrence_rule;
+    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;
+    const { data, error } = await this.supabase.from("tasks").update(updateData).eq("id", taskId).select().single();
+    if (error) throw error;
+    if (updates.tags !== void 0) {
+      await this.unlinkAllTaskTags(taskId);
+      if (updates.tags.length > 0) {
+        await this.linkTaskTags(taskId, updates.tags.map((t) => t.id));
+      }
+    }
+    return data;
+  }
+  async deleteTask(taskId) {
+    const { error } = await this.supabase.from("tasks").delete().eq("id", taskId);
+    if (error) throw error;
+  }
+  async completeTask(taskId) {
+    const { data, error } = await this.supabase.from("tasks").update({
+      completed: true,
+      completed_at: (/* @__PURE__ */ new Date()).toISOString()
+    }).eq("id", taskId).select().single();
+    if (error) throw error;
+    return data;
+  }
+  async uncompleteTask(taskId) {
+    const { data, error } = await this.supabase.from("tasks").update({
+      completed: false,
+      completed_at: null
+    }).eq("id", taskId).select().single();
+    if (error) throw error;
+    return data;
+  }
+  // ============================================
+  // TAG OPERATIONS
+  // ============================================
+  async getTags() {
+    const { data, error } = await this.supabase.from("tags").select("*").order("name", { ascending: true });
+    if (error) throw error;
+    return data;
+  }
+  async createTag(name, color = "#8B5CF6") {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) throw new Error("Not authenticated");
+    const { data, error } = await this.supabase.from("tags").insert({ user_id: user.id, name, color }).select().single();
+    if (error) throw error;
+    return data;
+  }
+  async linkTaskTags(taskId, tagIds) {
+    if (tagIds.length === 0) return;
+    const { error } = await this.supabase.from("task_tags").insert(tagIds.map((tagId) => ({ task_id: taskId, tag_id: tagId })));
+    if (error) throw error;
+  }
+  async unlinkAllTaskTags(taskId) {
+    const { error } = await this.supabase.from("task_tags").delete().eq("task_id", taskId);
+    if (error) throw error;
+  }
+  // ============================================
+  // SEARCH & UTILITY
+  // ============================================
+  async searchTasks(query, limit = 20) {
+    const { data, error } = await 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 (error) throw error;
+    return (data || []).map((task) => ({
+      ...task,
+      tags: task.tags?.map((t) => t.tag).filter(Boolean) || []
+    }));
+  }
+  /**
+   * Find tag by name (case-insensitive), create if doesn't exist
+   */
+  async findOrCreateTag(name, color) {
+    const tags = await this.getTags();
+    const existing = tags.find((t) => t.name.toLowerCase() === name.toLowerCase());
+    if (existing) {
+      return existing;
+    }
+    return await this.createTag(name, color);
+  }
+};
+export {
+  AuthManager,
+  ConfigManager,
+  TaskOperations,
+  createSupabaseClient,
+  createSupabaseClientFromEnv
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@vibetasks/core",
+  "version": "0.1.0",
+  "description": "Shared core logic for VibeTasks MCP server and CLI - authentication, task operations, and config management",
+  "author": "Vyas",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "vibetasks",
+    "vibe",
+    "vibecoding",
+    "mcp",
+    "task-management",
+    "supabase",
+    "authentication",
+    "productivity"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vyassathya/vibetasks.git",
+    "directory": "packages/mcp-core"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsup src/index.ts --format esm --clean --dts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.39.0",
+    "keytar": "^7.9.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.7.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.3"
+  }
+}