flowmind-mcp 1.0.0

package/dist/bin/flowmind-mcp.js

@@ -0,0 +1,906 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/config.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function loadConfig() {
+  const envKey = process.env.FLOWMIND_API_KEY;
+  const envUrl = process.env.FLOWMIND_BASE_URL;
+  if (envKey) {
+    return {
+      apiKey: envKey,
+      baseUrl: envUrl || "https://flowmind.life/api/v1"
+    };
+  }
+  try {
+    const configPath = join(homedir(), ".flowmind", "config.json");
+    const raw = readFileSync(configPath, "utf-8");
+    const config2 = JSON.parse(raw);
+    if (config2.api_key) {
+      return {
+        apiKey: config2.api_key,
+        baseUrl: config2.base_url || "https://flowmind.life/api/v1"
+      };
+    }
+  } catch {
+  }
+  throw new Error(
+    'FlowMind API key not configured.\nSet FLOWMIND_API_KEY environment variable, or create ~/.flowmind/config.json:\n{"api_key": "fm_xxx", "base_url": "https://flowmind.life/api/v1"}'
+  );
+}
+
+// src/client.ts
+import { readFileSync as readFileSync2 } from "fs";
+
+// src/utils.ts
+function formatList(result) {
+  const { data, meta } = result;
+  const { pagination } = meta;
+  const header = `Showing ${data.length} of ${pagination.total} (page ${pagination.page}/${pagination.totalPages})`;
+  return `${header}
+
+${JSON.stringify(data, null, 2)}`;
+}
+function formatItem(result) {
+  return JSON.stringify(result.data, null, 2);
+}
+function formatCreated(result, label) {
+  const id = result.data.id || "";
+  return `${label} created (ID: ${id})
+
+${JSON.stringify(result.data, null, 2)}`;
+}
+function formatUpdated(result, label) {
+  return `${label} updated
+
+${JSON.stringify(result.data, null, 2)}`;
+}
+function formatDeleted(label) {
+  return `${label} deleted successfully`;
+}
+function buildQueryString(params) {
+  const qs = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== null) {
+      qs.set(key, String(value));
+    }
+  }
+  const str = qs.toString();
+  return str ? `?${str}` : "";
+}
+function toolResult(text, isError = false) {
+  return {
+    content: [{ type: "text", text }],
+    ...isError ? { isError: true } : {}
+  };
+}
+function errorResult(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return toolResult(`Error: ${message}`, true);
+}
+
+// src/client.ts
+var FlowMindClient = class {
+  apiKey;
+  baseUrl;
+  constructor(config2) {
+    this.apiKey = config2.apiKey;
+    this.baseUrl = config2.baseUrl.replace(/\/$/, "");
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "Authorization": `Bearer ${this.apiKey}`
+    };
+    const init = { method, headers };
+    if (body !== void 0) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(body);
+    }
+    const res = await fetch(url, init);
+    if (res.status === 204) {
+      return void 0;
+    }
+    const json = await res.json();
+    if (!res.ok) {
+      const apiErr = json;
+      const msg = apiErr.error?.message || `API error ${res.status}`;
+      throw new Error(msg);
+    }
+    return json;
+  }
+  // ── Goals ──
+  async listGoals(params = {}) {
+    return this.request("GET", `/goals${buildQueryString(params)}`);
+  }
+  async getGoal(id) {
+    return this.request("GET", `/goals/${id}`);
+  }
+  async createGoal(data) {
+    return this.request("POST", "/goals", data);
+  }
+  async updateGoal(id, data) {
+    return this.request("PATCH", `/goals/${id}`, data);
+  }
+  async deleteGoal(id) {
+    await this.request("DELETE", `/goals/${id}`);
+  }
+  async listGoalTasks(goalId, params = {}) {
+    return this.request("GET", `/goals/${goalId}/tasks${buildQueryString(params)}`);
+  }
+  // ── Tasks ──
+  async listTasks(params = {}) {
+    return this.request("GET", `/tasks${buildQueryString(params)}`);
+  }
+  async getTask(id) {
+    return this.request("GET", `/tasks/${id}`);
+  }
+  async createTask(data) {
+    return this.request("POST", "/tasks", data);
+  }
+  async updateTask(id, data) {
+    return this.request("PATCH", `/tasks/${id}`, data);
+  }
+  async deleteTask(id) {
+    await this.request("DELETE", `/tasks/${id}`);
+  }
+  async listSubtasks(parentId, params = {}) {
+    return this.request("GET", `/tasks/${parentId}/subtasks${buildQueryString(params)}`);
+  }
+  async createSubtask(parentId, data) {
+    return this.request("POST", `/tasks/${parentId}/subtasks`, data);
+  }
+  // ── Notes ──
+  async listNotes(params = {}) {
+    return this.request("GET", `/notes${buildQueryString(params)}`);
+  }
+  async getNote(id) {
+    return this.request("GET", `/notes/${id}`);
+  }
+  async createNote(data) {
+    return this.request("POST", "/notes", data);
+  }
+  async updateNote(id, data) {
+    return this.request("PATCH", `/notes/${id}`, data);
+  }
+  async deleteNote(id) {
+    await this.request("DELETE", `/notes/${id}`);
+  }
+  // ── Note Images ──
+  async listNoteImages(noteId, params = {}) {
+    return this.request("GET", `/notes/${noteId}/images${buildQueryString(params)}`);
+  }
+  async uploadNoteImage(noteId, filePath, placeholderId, alt) {
+    const url = `${this.baseUrl}/notes/${noteId}/images`;
+    const fileBuffer = readFileSync2(filePath);
+    const fileName = filePath.split("/").pop() || "image.png";
+    const ext = fileName.split(".").pop()?.toLowerCase() || "png";
+    const mimeMap = {
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      png: "image/png",
+      gif: "image/gif",
+      webp: "image/webp"
+    };
+    const mimeType = mimeMap[ext] || "image/png";
+    const formData = new FormData();
+    formData.append("file", new Blob([fileBuffer], { type: mimeType }), fileName);
+    if (placeholderId) formData.append("placeholder_id", placeholderId);
+    if (alt) formData.append("alt", alt);
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Authorization": `Bearer ${this.apiKey}` },
+      body: formData
+    });
+    const json = await res.json();
+    if (!res.ok) {
+      const apiErr = json;
+      throw new Error(apiErr.error?.message || `Upload failed: ${res.status}`);
+    }
+    return json;
+  }
+  async deleteNoteImage(noteId, imageId) {
+    await this.request("DELETE", `/notes/${noteId}/images/${imageId}`);
+  }
+  // ── People ──
+  async listPeople(params = {}) {
+    return this.request("GET", `/people${buildQueryString(params)}`);
+  }
+  async getPerson(id) {
+    return this.request("GET", `/people/${id}`);
+  }
+  async createPerson(data) {
+    return this.request("POST", "/people", data);
+  }
+  async updatePerson(id, data) {
+    return this.request("PATCH", `/people/${id}`, data);
+  }
+  async deletePerson(id) {
+    await this.request("DELETE", `/people/${id}`);
+  }
+  async listPersonTags(personId) {
+    return this.request("GET", `/people/${personId}/tags`);
+  }
+  async addPersonTag(personId, tagId) {
+    return this.request("POST", `/people/${personId}/tags`, { tag_id: tagId });
+  }
+  async removePersonTag(personId, tagId) {
+    await this.request("DELETE", `/people/${personId}/tags/${tagId}`);
+  }
+  // ── Tags ──
+  async listTags(params = {}) {
+    return this.request("GET", `/tags${buildQueryString(params)}`);
+  }
+  async getTag(id) {
+    return this.request("GET", `/tags/${id}`);
+  }
+  async createTag(data) {
+    return this.request("POST", "/tags", data);
+  }
+  async updateTag(id, data) {
+    return this.request("PATCH", `/tags/${id}`, data);
+  }
+  async deleteTag(id) {
+    await this.request("DELETE", `/tags/${id}`);
+  }
+};
+
+// src/tools/goals.ts
+import { z } from "zod";
+function registerGoalTools(server2, client2) {
+  server2.tool(
+    "list_goals",
+    "List goals with optional filters for status, category, and pinned state. Returns paginated results.",
+    {
+      status: z.enum(["active", "completed", "archived"]).optional().describe("Filter by goal status"),
+      category: z.enum(["business", "career", "health", "personal", "learning", "financial"]).optional().describe("Filter by category"),
+      pinned: z.boolean().optional().describe("Filter by pinned state"),
+      sort: z.enum(["created_at", "updated_at", "title", "target_date", "progress"]).optional().describe("Sort field"),
+      order: z.enum(["asc", "desc"]).optional().describe("Sort direction"),
+      page: z.number().int().min(1).optional().describe("Page number"),
+      limit: z.number().int().min(1).max(100).optional().describe("Items per page")
+    },
+    async (params) => {
+      try {
+        const result = await client2.listGoals(params);
+        return toolResult(formatList(result));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "get_goal",
+    "Get the details of a specific goal by its ID.",
+    { id: z.string().describe("Goal ID (UUID)") },
+    async ({ id }) => {
+      try {
+        const result = await client2.getGoal(id);
+        return toolResult(formatItem(result));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "create_goal",
+    "Create a new goal. Goals help you organize tasks under high-level objectives.",
+    {
+      title: z.string().describe("Goal title (required)"),
+      description: z.string().optional().describe("Goal description"),
+      category: z.enum(["business", "career", "health", "personal", "learning", "financial"]).optional().describe("Category"),
+      target_date: z.string().optional().describe("Target date (YYYY-MM-DD)"),
+      status: z.enum(["active", "completed", "archived"]).optional().describe("Status"),
+      progress: z.number().int().min(0).max(100).optional().describe("Progress percentage (0-100)"),
+      pinned: z.boolean().optional().describe("Pin this goal")
+    },
+    async (params) => {
+      try {
+        const result = await client2.createGoal(params);
+        return toolResult(formatCreated(result, "Goal"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "update_goal",
+    "Update one or more fields on an existing goal.",
+    {
+      id: z.string().describe("Goal ID (UUID)"),
+      title: z.string().optional().describe("New title"),
+      description: z.string().optional().describe("New description"),
+      category: z.enum(["business", "career", "health", "personal", "learning", "financial"]).optional(),
+      target_date: z.string().optional().describe("New target date (YYYY-MM-DD)"),
+      status: z.enum(["active", "completed", "archived"]).optional(),
+      progress: z.number().int().min(0).max(100).optional(),
+      pinned: z.boolean().optional()
+    },
+    async ({ id, ...data }) => {
+      try {
+        const result = await client2.updateGoal(id, data);
+        return toolResult(formatUpdated(result, "Goal"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "delete_goal",
+    "Permanently delete a goal. Associated tasks are unlinked, not deleted.",
+    { id: z.string().describe("Goal ID (UUID)") },
+    async ({ id }) => {
+      try {
+        await client2.deleteGoal(id);
+        return toolResult(formatDeleted("Goal"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "list_goal_tasks",
+    "List all tasks associated with a specific goal.",
+    {
+      goal_id: z.string().describe("Goal ID (UUID)"),
+      status: z.enum(["todo", "in_progress", "completed", "archived"]).optional(),
+      priority: z.enum(["low", "medium", "high", "urgent"]).optional(),
+      page: z.number().int().min(1).optional(),
+      limit: z.number().int().min(1).max(100).optional()
+    },
+    async ({ goal_id, ...params }) => {
+      try {
+        const result = await client2.listGoalTasks(goal_id, params);
+        return toolResult(formatList(result));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+}
+
+// src/tools/tasks.ts
+import { z as z2 } from "zod";
+function registerTaskTools(server2, client2) {
+  server2.tool(
+    "list_tasks",
+    "List tasks with optional filters. Supports filtering by status, priority, energy level, goal, person, due date range, and focus state.",
+    {
+      status: z2.enum(["todo", "in_progress", "completed", "archived"]).optional(),
+      priority: z2.enum(["low", "medium", "high", "urgent"]).optional(),
+      energy_level: z2.enum(["low", "medium", "high"]).optional(),
+      goal_id: z2.string().optional().describe("Filter by goal ID"),
+      person_id: z2.string().optional().describe("Filter by person ID"),
+      parent_task_id: z2.string().optional().describe('Filter by parent task. Use "null" for root tasks only.'),
+      due_date_from: z2.string().optional().describe("Due date from (YYYY-MM-DD)"),
+      due_date_to: z2.string().optional().describe("Due date to (YYYY-MM-DD)"),
+      pinned: z2.boolean().optional(),
+      focused: z2.boolean().optional(),
+      focus_today: z2.boolean().optional(),
+      sort: z2.enum(["created_at", "updated_at", "due_date", "priority", "title"]).optional(),
+      order: z2.enum(["asc", "desc"]).optional(),
+      page: z2.number().int().min(1).optional(),
+      limit: z2.number().int().min(1).max(100).optional()
+    },
+    async (params) => {
+      try {
+        const result = await client2.listTasks(params);
+        return toolResult(formatList(result));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "get_task",
+    "Get the details of a specific task including priority, energy level, due date, and linked goal/person.",
+    { id: z2.string().describe("Task ID (UUID)") },
+    async ({ id }) => {
+      try {
+        const result = await client2.getTask(id);
+        return toolResult(formatItem(result));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "create_task",
+    "Create a new task. Tasks can be linked to goals, assigned to people, and organized with priorities and due dates.",
+    {
+      title: z2.string().describe("Task title (required)"),
+      description: z2.string().optional(),
+      status: z2.enum(["todo", "in_progress", "completed", "archived"]).optional(),
+      priority: z2.enum(["low", "medium", "high", "urgent"]).optional(),
+      energy_level: z2.enum(["low", "medium", "high"]).optional(),
+      due_date: z2.string().optional().describe("Due date (YYYY-MM-DD)"),
+      goal_id: z2.string().optional().describe("Link to a goal"),
+      person_id: z2.string().optional().describe("Assign to a person"),
+      estimated_minutes: z2.number().int().optional(),
+      pinned: z2.boolean().optional(),
+      focus_today: z2.boolean().optional()
+    },
+    async (params) => {
+      try {
+        const result = await client2.createTask(params);
+        return toolResult(formatCreated(result, "Task"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "update_task",
+    "Update one or more fields on an existing task.",
+    {
+      id: z2.string().describe("Task ID (UUID)"),
+      title: z2.string().optional(),
+      description: z2.string().optional(),
+      status: z2.enum(["todo", "in_progress", "completed", "archived"]).optional(),
+      priority: z2.enum(["low", "medium", "high", "urgent"]).optional(),
+      energy_level: z2.enum(["low", "medium", "high"]).optional(),
+      due_date: z2.string().optional(),
+      goal_id: z2.string().nullable().optional(),
+      person_id: z2.string().nullable().optional(),
+      estimated_minutes: z2.number().int().nullable().optional(),
+      pinned: z2.boolean().optional(),
+      focused: z2.boolean().optional(),
+      focus_today: z2.boolean().optional()
+    },
+    async ({ id, ...data }) => {
+      try {
+        const result = await client2.updateTask(id, data);
+        return toolResult(formatUpdated(result, "Task"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "delete_task",
+    "Permanently delete a task and all its subtasks.",
+    { id: z2.string().describe("Task ID (UUID)") },
+    async ({ id }) => {
+      try {
+        await client2.deleteTask(id);
+        return toolResult(formatDeleted("Task"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "list_subtasks",
+    "List subtasks (child tasks) for a specific parent task.",
+    {
+      parent_task_id: z2.string().describe("Parent task ID (UUID)"),
+      page: z2.number().int().min(1).optional(),
+      limit: z2.number().int().min(1).max(100).optional()
+    },
+    async ({ parent_task_id, ...params }) => {
+      try {
+        const result = await client2.listSubtasks(parent_task_id, params);
+        return toolResult(formatList(result));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "create_subtask",
+    "Create a new subtask under the specified parent task.",
+    {
+      parent_task_id: z2.string().describe("Parent task ID (UUID)"),
+      title: z2.string().describe("Subtask title (required)"),
+      description: z2.string().optional(),
+      priority: z2.enum(["low", "medium", "high", "urgent"]).optional(),
+      energy_level: z2.enum(["low", "medium", "high"]).optional(),
+      due_date: z2.string().optional(),
+      estimated_minutes: z2.number().int().optional()
+    },
+    async ({ parent_task_id, ...data }) => {
+      try {
+        const result = await client2.createSubtask(parent_task_id, data);
+        return toolResult(formatCreated(result, "Subtask"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+}
+
+// src/tools/notes.ts
+import { z as z3 } from "zod";
+function registerNoteTools(server2, client2) {
+  server2.tool(
+    "list_notes",
+    "List notes with optional filters. Note content with embedded images will have signed URLs automatically refreshed.",
+    {
+      category: z3.string().optional().describe("Filter by category"),
+      task_id: z3.string().optional().describe("Filter by linked task ID"),
+      pinned: z3.boolean().optional(),
+      sort: z3.enum(["created_at", "updated_at", "title"]).optional(),
+      order: z3.enum(["asc", "desc"]).optional(),
+      page: z3.number().int().min(1).optional(),
+      limit: z3.number().int().min(1).max(100).optional()
+    },
+    async (params) => {
+      try {
+        const result = await client2.listNotes(params);
+        return toolResult(formatList(result));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "get_note",
+    "Get a note by ID. Embedded image URLs are automatically refreshed.",
+    { id: z3.string().describe("Note ID (UUID)") },
+    async ({ id }) => {
+      try {
+        const result = await client2.getNote(id);
+        return toolResult(formatItem(result));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "create_note",
+    "Create a new note. Content can include {{IMG:placeholder_id}} markers for image insertion \u2014 upload images via upload_note_image to replace them.",
+    {
+      title: z3.string().describe("Note title (required)"),
+      content: z3.string().optional().describe("Note content (supports Markdown and {{IMG:id}} placeholders)"),
+      category: z3.string().optional(),
+      task_id: z3.string().optional().describe("Link to a task"),
+      is_protected: z3.boolean().optional(),
+      pinned: z3.boolean().optional()
+    },
+    async (params) => {
+      try {
+        const result = await client2.createNote(params);
+        return toolResult(formatCreated(result, "Note"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "update_note",
+    "Update one or more fields on an existing note. Existing embedded images are preserved.",
+    {
+      id: z3.string().describe("Note ID (UUID)"),
+      title: z3.string().optional(),
+      content: z3.string().optional(),
+      category: z3.string().nullable().optional(),
+      task_id: z3.string().nullable().optional(),
+      is_protected: z3.boolean().optional(),
+      pinned: z3.boolean().optional()
+    },
+    async ({ id, ...data }) => {
+      try {
+        const result = await client2.updateNote(id, data);
+        return toolResult(formatUpdated(result, "Note"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "delete_note",
+    "Permanently delete a note and all its image attachments.",
+    { id: z3.string().describe("Note ID (UUID)") },
+    async ({ id }) => {
+      try {
+        await client2.deleteNote(id);
+        return toolResult(formatDeleted("Note"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "list_note_images",
+    "List image attachments for a note, each with a fresh signed URL.",
+    {
+      note_id: z3.string().describe("Note ID (UUID)"),
+      page: z3.number().int().min(1).optional(),
+      limit: z3.number().int().min(1).max(100).optional()
+    },
+    async ({ note_id, ...params }) => {
+      try {
+        const result = await client2.listNoteImages(note_id, params);
+        return toolResult(formatList(result));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "upload_note_image",
+    "Upload an image to a note. If placeholder_id matches a {{IMG:id}} marker in note content, it is replaced with an <img> tag. Max 25MB, JPEG/PNG/GIF/WebP.",
+    {
+      note_id: z3.string().describe("Note ID (UUID)"),
+      file_path: z3.string().describe("Local path to the image file"),
+      placeholder_id: z3.string().optional().describe("Placeholder ID to replace in note content"),
+      alt: z3.string().optional().describe("Alt text for the image")
+    },
+    async ({ note_id, file_path, placeholder_id, alt }) => {
+      try {
+        const result = await client2.uploadNoteImage(note_id, file_path, placeholder_id, alt);
+        const data = result.data;
+        const status = data.replaced ? "uploaded and placeholder replaced" : "uploaded as attachment";
+        return toolResult(`Image ${status} (ID: ${data.id})
+
+${JSON.stringify(data, null, 2)}`);
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "delete_note_image",
+    "Delete an image attachment and remove its <img> tag from note content.",
+    {
+      note_id: z3.string().describe("Note ID (UUID)"),
+      image_id: z3.string().describe("Image attachment ID (UUID)")
+    },
+    async ({ note_id, image_id }) => {
+      try {
+        await client2.deleteNoteImage(note_id, image_id);
+        return toolResult(formatDeleted("Note image"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+}
+
+// src/tools/people.ts
+import { z as z4 } from "zod";
+function registerPeopleTools(server2, client2) {
+  server2.tool(
+    "list_people",
+    "List contacts with optional filters for relationship type, tag, or search.",
+    {
+      relationship_type: z4.enum(["business", "colleague", "friend", "family", "mentor", "client", "partner", "other"]).optional(),
+      tag_id: z4.string().optional().describe("Filter by tag ID"),
+      search: z4.string().optional().describe("Search by name, email, or company"),
+      sort: z4.enum(["created_at", "updated_at", "name"]).optional(),
+      order: z4.enum(["asc", "desc"]).optional(),
+      page: z4.number().int().min(1).optional(),
+      limit: z4.number().int().min(1).max(100).optional()
+    },
+    async (params) => {
+      try {
+        const result = await client2.listPeople(params);
+        return toolResult(formatList(result));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "get_person",
+    "Get the details of a specific person by their ID.",
+    { id: z4.string().describe("Person ID (UUID)") },
+    async ({ id }) => {
+      try {
+        const result = await client2.getPerson(id);
+        return toolResult(formatItem(result));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "create_person",
+    "Create a new contact. People can be linked to tasks and tagged for organization.",
+    {
+      name: z4.string().describe("Person name (required)"),
+      email: z4.string().optional(),
+      phone: z4.string().optional(),
+      company: z4.string().optional(),
+      role: z4.string().optional().describe("Job title"),
+      relationship_type: z4.enum(["business", "colleague", "friend", "family", "mentor", "client", "partner", "other"]).optional(),
+      notes: z4.string().optional(),
+      location: z4.string().optional(),
+      birthday: z4.string().optional().describe("Birthday (YYYY-MM-DD)")
+    },
+    async (params) => {
+      try {
+        const result = await client2.createPerson(params);
+        return toolResult(formatCreated(result, "Person"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "update_person",
+    "Update one or more fields on an existing person.",
+    {
+      id: z4.string().describe("Person ID (UUID)"),
+      name: z4.string().optional(),
+      email: z4.string().nullable().optional(),
+      phone: z4.string().nullable().optional(),
+      company: z4.string().nullable().optional(),
+      role: z4.string().nullable().optional(),
+      relationship_type: z4.enum(["business", "colleague", "friend", "family", "mentor", "client", "partner", "other"]).optional(),
+      notes: z4.string().nullable().optional(),
+      location: z4.string().nullable().optional()
+    },
+    async ({ id, ...data }) => {
+      try {
+        const result = await client2.updatePerson(id, data);
+        return toolResult(formatUpdated(result, "Person"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "delete_person",
+    "Permanently delete a person and remove all their tag associations.",
+    { id: z4.string().describe("Person ID (UUID)") },
+    async ({ id }) => {
+      try {
+        await client2.deletePerson(id);
+        return toolResult(formatDeleted("Person"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "list_person_tags",
+    "List all tags assigned to a specific person.",
+    { person_id: z4.string().describe("Person ID (UUID)") },
+    async ({ person_id }) => {
+      try {
+        const result = await client2.listPersonTags(person_id);
+        return toolResult(JSON.stringify(result.data, null, 2));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "add_person_tag",
+    "Assign an existing tag to a person. Returns 409 if already assigned.",
+    {
+      person_id: z4.string().describe("Person ID (UUID)"),
+      tag_id: z4.string().describe("Tag ID (UUID)")
+    },
+    async ({ person_id, tag_id }) => {
+      try {
+        const result = await client2.addPersonTag(person_id, tag_id);
+        return toolResult(`Tag assigned
+
+${JSON.stringify(result.data, null, 2)}`);
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "remove_person_tag",
+    "Remove a tag from a person. The tag itself is not deleted.",
+    {
+      person_id: z4.string().describe("Person ID (UUID)"),
+      tag_id: z4.string().describe("Tag ID (UUID)")
+    },
+    async ({ person_id, tag_id }) => {
+      try {
+        await client2.removePersonTag(person_id, tag_id);
+        return toolResult("Tag removed from person");
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+}
+
+// src/tools/tags.ts
+import { z as z5 } from "zod";
+function registerTagTools(server2, client2) {
+  server2.tool(
+    "list_tags",
+    "List all tags. Tags are used to categorize people.",
+    {
+      sort: z5.enum(["name", "created_at"]).optional(),
+      order: z5.enum(["asc", "desc"]).optional(),
+      page: z5.number().int().min(1).optional(),
+      limit: z5.number().int().min(1).max(100).optional()
+    },
+    async (params) => {
+      try {
+        const result = await client2.listTags(params);
+        return toolResult(formatList(result));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "get_tag",
+    "Get the details of a specific tag by its ID.",
+    { id: z5.string().describe("Tag ID (UUID)") },
+    async ({ id }) => {
+      try {
+        const result = await client2.getTag(id);
+        return toolResult(formatItem(result));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "create_tag",
+    "Create a new tag. Tag names must be unique \u2014 returns 409 if a tag with the same name exists.",
+    {
+      name: z5.string().describe("Tag name (required, must be unique)"),
+      color: z5.string().optional().describe("Tag color (hex code, e.g. #ff0000)")
+    },
+    async (params) => {
+      try {
+        const result = await client2.createTag(params);
+        return toolResult(formatCreated(result, "Tag"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "update_tag",
+    "Update a tag name or color. Returns 409 if the new name conflicts with an existing tag.",
+    {
+      id: z5.string().describe("Tag ID (UUID)"),
+      name: z5.string().optional(),
+      color: z5.string().optional()
+    },
+    async ({ id, ...data }) => {
+      try {
+        const result = await client2.updateTag(id, data);
+        return toolResult(formatUpdated(result, "Tag"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.tool(
+    "delete_tag",
+    "Permanently delete a tag and remove it from all people.",
+    { id: z5.string().describe("Tag ID (UUID)") },
+    async ({ id }) => {
+      try {
+        await client2.deleteTag(id);
+        return toolResult(formatDeleted("Tag"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+}
+
+// src/index.ts
+var config = loadConfig();
+var client = new FlowMindClient(config);
+var server = new McpServer({
+  name: "flowmind",
+  version: "1.0.0"
+});
+registerGoalTools(server, client);
+registerTaskTools(server, client);
+registerNoteTools(server, client);
+registerPeopleTools(server, client);
+registerTagTools(server, client);
+var transport = new StdioServerTransport();
+await server.connect(transport);
+//# sourceMappingURL=flowmind-mcp.js.map