@studiometa/productive-mcp 0.6.4 → 0.8.0

package/dist/index-D743zTS1.js

@@ -0,0 +1,1177 @@
+import { formatBooking as formatBooking$1, formatListResponse as formatListResponse$1, formatDeal as formatDeal$1, formatTimer as formatTimer$1, formatComment as formatComment$1, formatCompany as formatCompany$1, formatPerson as formatPerson$1, formatService as formatService$1, formatTask as formatTask$1, formatTimeEntry as formatTimeEntry$1, formatProject as formatProject$1, ProductiveApi } from "@studiometa/productive-cli";
+class UserInputError extends Error {
+  hints;
+  constructor(message, hints) {
+    super(message);
+    this.name = "UserInputError";
+    this.hints = hints;
+  }
+  /**
+   * Format error message with hints for LLM consumption
+   */
+  toFormattedMessage() {
+    let msg = `**Input Error:** ${this.message}`;
+    if (this.hints && this.hints.length > 0) {
+      msg += "\n\n**Hints:**\n" + this.hints.map((h) => `- ${h}`).join("\n");
+    }
+    return msg;
+  }
+}
+const ErrorMessages = {
+  // Required field errors
+  missingId: (action) => new UserInputError(`id is required for ${action} action`, [
+    `Use action="list" first to find the resource ID`,
+    `Then use action="${action}" with the id parameter`
+  ]),
+  missingRequiredFields: (resource, fields) => new UserInputError(
+    `${fields.join(", ")} ${fields.length === 1 ? "is" : "are"} required for creating ${resource}`,
+    [
+      `Provide all required fields: ${fields.join(", ")}`,
+      `Use action="help" for detailed documentation on ${resource}`
+    ]
+  ),
+  // Invalid action errors
+  invalidAction: (action, resource, validActions) => new UserInputError(`Invalid action "${action}" for ${resource}`, [
+    `Valid actions are: ${validActions.join(", ")}`,
+    `Use action="help" with resource="${resource}" for detailed documentation`
+  ]),
+  // Unknown resource errors
+  unknownResource: (resource, validResources) => new UserInputError(`Unknown resource: ${resource}`, [
+    `Valid resources are: ${validResources.join(", ")}`,
+    `Use action="help" without a resource for an overview of all resources`
+  ]),
+  // Report-specific errors
+  missingReportType: () => new UserInputError("report_type is required for reports", [
+    'Specify report_type parameter (e.g., "time_reports", "project_reports")',
+    'Use action="help" with resource="reports" for available report types'
+  ]),
+  invalidReportType: (reportType, validTypes) => new UserInputError(`Invalid report_type: ${reportType}`, [
+    `Valid report types are: ${validTypes.join(", ")}`,
+    'Use action="help" with resource="reports" for detailed documentation'
+  ]),
+  // Timer-specific errors
+  missingServiceForTimer: () => new UserInputError("service_id is required to start a timer", [
+    'First find a service using resource="services" action="list"',
+    "Then start the timer with the service_id"
+  ]),
+  // People-specific errors
+  noUserIdConfigured: () => new UserInputError("User ID not configured", [
+    'The "me" action requires a user ID to be configured',
+    'Use action="list" to find people, or configure the user ID'
+  ]),
+  // Comment-specific errors
+  missingCommentTarget: () => new UserInputError("A target is required for creating a comment", [
+    "Provide one of: task_id, deal_id, or company_id",
+    'Find targets using resource="tasks", "deals", or "companies" with action="list"'
+  ]),
+  // Booking-specific errors
+  missingBookingTarget: () => new UserInputError("A service or event is required for creating a booking", [
+    "Provide either: service_id or event_id",
+    'Find services using resource="services" with action="list"'
+  ]),
+  // API errors
+  apiError: (statusCode, message) => {
+    const hints = [];
+    if (statusCode === 401) {
+      hints.push("Check that your API token is valid and not expired");
+      hints.push("Verify the organization ID is correct");
+    } else if (statusCode === 403) {
+      hints.push("You may not have permission to access this resource");
+      hints.push("Check your API token permissions");
+    } else if (statusCode === 404) {
+      hints.push("The resource may not exist or you may not have access");
+      hints.push("Verify the resource ID is correct");
+      hints.push('Use action="list" to find valid resource IDs');
+    } else if (statusCode === 422) {
+      hints.push("The request data may be invalid");
+      hints.push("Check the field values and types");
+      hints.push('Use action="help" for field documentation');
+    } else if (statusCode >= 500) {
+      hints.push("This is a server error - try again later");
+    }
+    return new UserInputError(`API error (${statusCode}): ${message}`, hints);
+  }
+};
+function isUserInputError(error) {
+  return error instanceof UserInputError;
+}
+const MCP_FORMAT_OPTIONS = {
+  includeRelationshipIds: false,
+  includeTimestamps: false,
+  stripHtml: true
+};
+function compactify(obj, fieldsToRemove) {
+  const result = { ...obj };
+  for (const field of fieldsToRemove) {
+    delete result[field];
+  }
+  return result;
+}
+function formatTimeEntry(entry, options) {
+  const result = formatTimeEntry$1(entry, MCP_FORMAT_OPTIONS);
+  if (options?.compact) {
+    return compactify(result, ["note", "billable_time", "approved"]);
+  }
+  return result;
+}
+function formatProject(project, options) {
+  const result = formatProject$1(project, MCP_FORMAT_OPTIONS);
+  if (options?.compact) {
+    return compactify(result, ["budget"]);
+  }
+  return result;
+}
+function formatTask(task, options) {
+  const result = formatTask$1(task, { ...MCP_FORMAT_OPTIONS, included: options?.included });
+  if (options?.compact) {
+    return compactify(result, [
+      "description",
+      "initial_estimate",
+      "worked_time",
+      "remaining_time",
+      "project",
+      // Keep project_name but remove nested object
+      "company"
+      // Keep company name inline if needed
+    ]);
+  }
+  return result;
+}
+function formatPerson(person, options) {
+  const result = formatPerson$1(person, MCP_FORMAT_OPTIONS);
+  if (options?.compact) {
+    return compactify(result, ["title", "first_name", "last_name"]);
+  }
+  return result;
+}
+function formatService(service, options) {
+  const result = formatService$1(service, MCP_FORMAT_OPTIONS);
+  if (options?.compact) {
+    return compactify(result, ["budgeted_time", "worked_time"]);
+  }
+  return result;
+}
+function formatCompany(company, options) {
+  const result = formatCompany$1(company, MCP_FORMAT_OPTIONS);
+  if (options?.compact) {
+    return compactify(result, ["billing_name", "domain", "due_days"]);
+  }
+  return result;
+}
+function formatComment(comment, options) {
+  const result = formatComment$1(comment, { ...MCP_FORMAT_OPTIONS, included: options?.included });
+  return result;
+}
+function formatTimer(timer, _options) {
+  const result = formatTimer$1(timer, MCP_FORMAT_OPTIONS);
+  return result;
+}
+function formatDeal(deal, options) {
+  const result = formatDeal$1(deal, { ...MCP_FORMAT_OPTIONS, included: options?.included });
+  if (options?.compact) {
+    return compactify(result, ["won_at", "lost_at"]);
+  }
+  return result;
+}
+function formatBooking(booking, options) {
+  const result = formatBooking$1(booking, { ...MCP_FORMAT_OPTIONS, included: options?.included });
+  if (options?.compact) {
+    return compactify(result, ["approved_at", "rejected_at", "rejected_reason"]);
+  }
+  return result;
+}
+function formatListResponse(data, formatter, meta, options) {
+  const wrappedFormatter = (item, _cliOptions) => {
+    return formatter(item, options);
+  };
+  const result = formatListResponse$1(data, wrappedFormatter, meta, {
+    ...MCP_FORMAT_OPTIONS,
+    included: options?.included
+  });
+  return result;
+}
+function jsonResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+function errorResult(message) {
+  return {
+    content: [{ type: "text", text: `**Error:** ${message}` }],
+    isError: true
+  };
+}
+function inputErrorResult(error) {
+  return {
+    content: [{ type: "text", text: error.toFormattedMessage() }],
+    isError: true
+  };
+}
+function formatError(error) {
+  if (isUserInputError(error)) {
+    return inputErrorResult(error);
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return errorResult(message);
+}
+function toStringFilter(filter) {
+  if (!filter) return void 0;
+  const result = {};
+  for (const [key, value] of Object.entries(filter)) {
+    if (value !== void 0 && value !== null) {
+      result[key] = String(value);
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+const DEFAULT_BOOKING_INCLUDE = ["person", "service"];
+const VALID_ACTIONS$a = ["list", "get", "create", "update"];
+async function handleBookings(action, args, ctx) {
+  const { api, formatOptions, filter, page, perPage, include: userInclude } = ctx;
+  const { id, person_id, service_id, event_id, started_on, ended_on, time, note } = args;
+  const include = userInclude?.length ? [.../* @__PURE__ */ new Set([...DEFAULT_BOOKING_INCLUDE, ...userInclude])] : DEFAULT_BOOKING_INCLUDE;
+  if (action === "get") {
+    if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+    const result = await api.getBooking(id, { include });
+    return jsonResult(formatBooking(result.data, { ...formatOptions, included: result.included }));
+  }
+  if (action === "create") {
+    if (!person_id || !started_on || !ended_on) {
+      return inputErrorResult(
+        ErrorMessages.missingRequiredFields("booking", ["person_id", "started_on", "ended_on"])
+      );
+    }
+    if (!service_id && !event_id) {
+      return inputErrorResult(ErrorMessages.missingBookingTarget());
+    }
+    const result = await api.createBooking({
+      person_id,
+      service_id,
+      event_id,
+      started_on,
+      ended_on,
+      time,
+      note
+    });
+    return jsonResult({ success: true, ...formatBooking(result.data, formatOptions) });
+  }
+  if (action === "update") {
+    if (!id) return inputErrorResult(ErrorMessages.missingId("update"));
+    const updateData = {};
+    if (started_on !== void 0) updateData.started_on = started_on;
+    if (ended_on !== void 0) updateData.ended_on = ended_on;
+    if (time !== void 0) updateData.time = time;
+    if (note !== void 0) updateData.note = note;
+    const result = await api.updateBooking(id, updateData);
+    return jsonResult({ success: true, ...formatBooking(result.data, formatOptions) });
+  }
+  if (action === "list") {
+    const result = await api.getBookings({ filter, page, perPage, include });
+    return jsonResult(
+      formatListResponse(result.data, formatBooking, result.meta, {
+        ...formatOptions,
+        included: result.included
+      })
+    );
+  }
+  return inputErrorResult(ErrorMessages.invalidAction(action, "bookings", VALID_ACTIONS$a));
+}
+const DEFAULT_COMMENT_INCLUDE = ["creator"];
+const VALID_ACTIONS$9 = ["list", "get", "create", "update"];
+async function handleComments(action, args, ctx) {
+  const { api, formatOptions, filter, page, perPage, include: userInclude } = ctx;
+  const { id, body, task_id, deal_id, company_id } = args;
+  const include = userInclude?.length ? [.../* @__PURE__ */ new Set([...DEFAULT_COMMENT_INCLUDE, ...userInclude])] : DEFAULT_COMMENT_INCLUDE;
+  if (action === "get") {
+    if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+    const result = await api.getComment(id, { include });
+    return jsonResult(formatComment(result.data, { ...formatOptions, included: result.included }));
+  }
+  if (action === "create") {
+    if (!body) return inputErrorResult(ErrorMessages.missingRequiredFields("comment", ["body"]));
+    if (!task_id && !deal_id && !company_id) {
+      return inputErrorResult(ErrorMessages.missingCommentTarget());
+    }
+    const result = await api.createComment({
+      body,
+      task_id,
+      deal_id,
+      company_id
+    });
+    return jsonResult({ success: true, ...formatComment(result.data, formatOptions) });
+  }
+  if (action === "update") {
+    if (!id) return inputErrorResult(ErrorMessages.missingId("update"));
+    if (!body)
+      return inputErrorResult(ErrorMessages.missingRequiredFields("comment update", ["body"]));
+    const result = await api.updateComment(id, { body });
+    return jsonResult({ success: true, ...formatComment(result.data, formatOptions) });
+  }
+  if (action === "list") {
+    const result = await api.getComments({ filter, page, perPage, include });
+    return jsonResult(
+      formatListResponse(result.data, formatComment, result.meta, {
+        ...formatOptions,
+        included: result.included
+      })
+    );
+  }
+  return inputErrorResult(ErrorMessages.invalidAction(action, "comments", VALID_ACTIONS$9));
+}
+const VALID_ACTIONS$8 = ["list", "get", "create", "update"];
+async function handleCompanies(action, args, ctx) {
+  const { api, formatOptions, filter, page, perPage } = ctx;
+  const { id, name } = args;
+  if (action === "get") {
+    if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+    const result = await api.getCompany(id);
+    return jsonResult(formatCompany(result.data, formatOptions));
+  }
+  if (action === "create") {
+    if (!name) return inputErrorResult(ErrorMessages.missingRequiredFields("company", ["name"]));
+    const result = await api.createCompany({ name });
+    return jsonResult({ success: true, ...formatCompany(result.data, formatOptions) });
+  }
+  if (action === "update") {
+    if (!id) return inputErrorResult(ErrorMessages.missingId("update"));
+    const updateData = {};
+    if (name !== void 0) updateData.name = name;
+    const result = await api.updateCompany(id, updateData);
+    return jsonResult({ success: true, ...formatCompany(result.data, formatOptions) });
+  }
+  if (action === "list") {
+    const result = await api.getCompanies({ filter, page, perPage });
+    return jsonResult(formatListResponse(result.data, formatCompany, result.meta, formatOptions));
+  }
+  return inputErrorResult(ErrorMessages.invalidAction(action, "companies", VALID_ACTIONS$8));
+}
+const DEFAULT_DEAL_INCLUDE_GET = ["company", "deal_status", "responsible"];
+const DEFAULT_DEAL_INCLUDE_LIST = ["company", "deal_status"];
+const VALID_ACTIONS$7 = ["list", "get", "create", "update"];
+async function handleDeals(action, args, ctx) {
+  const { api, formatOptions, filter, page, perPage, include: userInclude } = ctx;
+  const { id, name, company_id } = args;
+  if (action === "get") {
+    if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+    const include = userInclude?.length ? [.../* @__PURE__ */ new Set([...DEFAULT_DEAL_INCLUDE_GET, ...userInclude])] : DEFAULT_DEAL_INCLUDE_GET;
+    const result = await api.getDeal(id, { include });
+    return jsonResult(formatDeal(result.data, { ...formatOptions, included: result.included }));
+  }
+  if (action === "create") {
+    if (!name || !company_id) {
+      return inputErrorResult(ErrorMessages.missingRequiredFields("deal", ["name", "company_id"]));
+    }
+    const result = await api.createDeal({ name, company_id });
+    return jsonResult({ success: true, ...formatDeal(result.data, formatOptions) });
+  }
+  if (action === "update") {
+    if (!id) return inputErrorResult(ErrorMessages.missingId("update"));
+    const updateData = {};
+    if (name !== void 0) updateData.name = name;
+    const result = await api.updateDeal(id, updateData);
+    return jsonResult({ success: true, ...formatDeal(result.data, formatOptions) });
+  }
+  if (action === "list") {
+    const include = userInclude?.length ? [.../* @__PURE__ */ new Set([...DEFAULT_DEAL_INCLUDE_LIST, ...userInclude])] : DEFAULT_DEAL_INCLUDE_LIST;
+    const result = await api.getDeals({
+      filter,
+      page,
+      perPage,
+      include
+    });
+    return jsonResult(
+      formatListResponse(result.data, formatDeal, result.meta, {
+        ...formatOptions,
+        included: result.included
+      })
+    );
+  }
+  return inputErrorResult(ErrorMessages.invalidAction(action, "deals", VALID_ACTIONS$7));
+}
+const RESOURCE_HELP = {
+  projects: {
+    description: "Manage projects in Productive.io",
+    actions: {
+      list: "List all projects with optional filters",
+      get: "Get a single project by ID with full details"
+    },
+    filters: {
+      query: "Text search on project name",
+      project_type_id: "Filter by project type",
+      company_id: "Filter by company",
+      archived: "Filter by archived status (true/false)"
+    },
+    fields: {
+      id: "Unique project identifier",
+      name: "Project name",
+      project_number: "Project reference number",
+      archived: "Whether the project is archived",
+      budget: "Project budget amount"
+    },
+    examples: [
+      {
+        description: "Search projects by name",
+        params: { resource: "projects", action: "list", query: "website" }
+      },
+      {
+        description: "List active projects",
+        params: { resource: "projects", action: "list", filter: { archived: "false" } }
+      },
+      {
+        description: "Get project details",
+        params: { resource: "projects", action: "get", id: "12345" }
+      }
+    ]
+  },
+  tasks: {
+    description: "Manage tasks within projects",
+    actions: {
+      list: "List tasks with optional filters",
+      get: "Get a single task by ID with full details (description, comments, etc.)",
+      create: "Create a new task (requires title, project_id, task_list_id)",
+      update: "Update an existing task"
+    },
+    filters: {
+      query: "Text search on task title",
+      project_id: "Filter by project",
+      assignee_id: "Filter by assigned person",
+      status: "Filter by status (open, closed, all)",
+      task_list_id: "Filter by task list"
+    },
+    includes: [
+      "project",
+      "project.company",
+      "assignee",
+      "workflow_status",
+      "comments",
+      "attachments",
+      "subtasks"
+    ],
+    fields: {
+      id: "Unique task identifier",
+      title: "Task title",
+      description: "Full task description (HTML)",
+      number: "Task number within project",
+      due_date: "Due date (YYYY-MM-DD)",
+      initial_estimate: "Estimated time in minutes",
+      worked_time: "Logged time in minutes",
+      remaining_time: "Remaining time in minutes",
+      closed: "Whether the task is closed"
+    },
+    examples: [
+      {
+        description: "Search tasks by title",
+        params: { resource: "tasks", action: "list", query: "bug fix" }
+      },
+      {
+        description: "List open tasks for a project",
+        params: {
+          resource: "tasks",
+          action: "list",
+          filter: { project_id: "12345", status: "open" }
+        }
+      },
+      {
+        description: "Get task with comments",
+        params: {
+          resource: "tasks",
+          action: "get",
+          id: "67890",
+          include: ["comments", "assignee"]
+        }
+      },
+      {
+        description: "Create a task",
+        params: {
+          resource: "tasks",
+          action: "create",
+          title: "New task",
+          project_id: "12345",
+          task_list_id: "111"
+        }
+      }
+    ]
+  },
+  time: {
+    description: "Track time entries against services/tasks",
+    actions: {
+      list: "List time entries with optional filters",
+      get: "Get a single time entry by ID",
+      create: "Create a new time entry (requires person_id, service_id, date, time)",
+      update: "Update an existing time entry"
+    },
+    filters: {
+      person_id: "Filter by person",
+      service_id: "Filter by service",
+      project_id: "Filter by project",
+      after: "Filter entries after date (YYYY-MM-DD)",
+      before: "Filter entries before date (YYYY-MM-DD)"
+    },
+    fields: {
+      id: "Unique time entry identifier",
+      date: "Date of the entry (YYYY-MM-DD)",
+      time: "Time in minutes",
+      note: "Description of work done",
+      billable_time: "Billable time in minutes",
+      approved: "Whether the entry is approved"
+    },
+    examples: [
+      {
+        description: "List my time entries this week",
+        params: {
+          resource: "time",
+          action: "list",
+          filter: { person_id: "me", after: "2024-01-15", before: "2024-01-21" }
+        }
+      },
+      {
+        description: "Log 2 hours",
+        params: {
+          resource: "time",
+          action: "create",
+          service_id: "12345",
+          date: "2024-01-16",
+          time: 120,
+          note: "Development work"
+        }
+      }
+    ]
+  },
+  services: {
+    description: "Budget line items within projects",
+    actions: {
+      list: "List services with optional filters",
+      get: "Get a single service by ID"
+    },
+    filters: {
+      project_id: "Filter by project",
+      deal_id: "Filter by deal"
+    },
+    fields: {
+      id: "Unique service identifier",
+      name: "Service name",
+      budgeted_time: "Budgeted time in minutes",
+      worked_time: "Logged time in minutes"
+    },
+    examples: [
+      {
+        description: "List services for a project",
+        params: { resource: "services", action: "list", filter: { project_id: "12345" } }
+      }
+    ]
+  },
+  people: {
+    description: "Team members and contacts",
+    actions: {
+      list: "List people with optional filters",
+      get: "Get a single person by ID",
+      me: "Get the currently authenticated user"
+    },
+    filters: {
+      query: "Text search on name or email",
+      status: "Filter by status (active, inactive)"
+    },
+    fields: {
+      id: "Unique person identifier",
+      name: "Full name",
+      first_name: "First name",
+      last_name: "Last name",
+      email: "Email address",
+      title: "Job title",
+      active: "Whether the person is active"
+    },
+    examples: [
+      { description: "Get current user", params: { resource: "people", action: "me" } },
+      {
+        description: "Search people by name",
+        params: { resource: "people", action: "list", query: "john" }
+      },
+      {
+        description: "List active team members",
+        params: { resource: "people", action: "list", filter: { status: "active" } }
+      }
+    ]
+  },
+  companies: {
+    description: "Client companies and organizations",
+    actions: {
+      list: "List companies with optional filters",
+      get: "Get a single company by ID",
+      create: "Create a new company (requires name)",
+      update: "Update an existing company"
+    },
+    filters: {
+      query: "Text search on company name",
+      archived: "Filter by archived status (true/false)"
+    },
+    fields: {
+      id: "Unique company identifier",
+      name: "Company name",
+      billing_name: "Legal/billing name",
+      domain: "Website domain",
+      vat: "VAT number"
+    },
+    examples: [
+      {
+        description: "Search companies",
+        params: { resource: "companies", action: "list", query: "acme" }
+      },
+      {
+        description: "List active companies",
+        params: { resource: "companies", action: "list", filter: { archived: "false" } }
+      }
+    ]
+  },
+  comments: {
+    description: "Comments on tasks, deals, and other resources",
+    actions: {
+      list: "List comments with optional filters",
+      get: "Get a single comment by ID",
+      create: "Create a new comment (requires body and one of: task_id, deal_id, company_id)",
+      update: "Update an existing comment"
+    },
+    filters: {
+      task_id: "Filter by task",
+      deal_id: "Filter by deal"
+    },
+    includes: ["creator", "task", "deal"],
+    fields: {
+      id: "Unique comment identifier",
+      body: "Comment text (may contain HTML)",
+      creator: "Person who created the comment"
+    },
+    examples: [
+      {
+        description: "List comments on a task",
+        params: { resource: "comments", action: "list", filter: { task_id: "12345" } }
+      },
+      {
+        description: "Add a comment",
+        params: { resource: "comments", action: "create", task_id: "12345", body: "Looking good!" }
+      }
+    ]
+  },
+  timers: {
+    description: "Active time tracking timers",
+    actions: {
+      list: "List active timers",
+      get: "Get a single timer by ID",
+      start: "Start a new timer (requires service_id or time_entry_id)",
+      stop: "Stop an active timer by ID"
+    },
+    fields: {
+      id: "Unique timer identifier",
+      started_at: "When the timer started (ISO 8601)",
+      total_time: "Elapsed time in seconds"
+    },
+    examples: [
+      { description: "List active timers", params: { resource: "timers", action: "list" } },
+      {
+        description: "Start timer on service",
+        params: { resource: "timers", action: "start", service_id: "12345" }
+      },
+      { description: "Stop timer", params: { resource: "timers", action: "stop", id: "67890" } }
+    ]
+  },
+  deals: {
+    description: "Sales deals and opportunities",
+    actions: {
+      list: "List deals with optional filters",
+      get: "Get a single deal by ID",
+      create: "Create a new deal (requires name, company_id)",
+      update: "Update an existing deal"
+    },
+    filters: {
+      query: "Text search on deal name",
+      company_id: "Filter by company",
+      deal_status_id: "Filter by status"
+    },
+    includes: ["company", "deal_status", "responsible", "project"],
+    fields: {
+      id: "Unique deal identifier",
+      name: "Deal name",
+      number: "Deal number",
+      date: "Deal date",
+      status: "Current status (from deal_status)"
+    },
+    examples: [
+      {
+        description: "Search deals",
+        params: { resource: "deals", action: "list", query: "website redesign" }
+      },
+      {
+        description: "List deals for a company",
+        params: { resource: "deals", action: "list", filter: { company_id: "12345" } }
+      }
+    ]
+  },
+  bookings: {
+    description: "Resource scheduling and capacity planning",
+    actions: {
+      list: "List bookings with optional filters",
+      get: "Get a single booking by ID",
+      create: "Create a new booking (requires person_id, started_on, ended_on, and service_id or event_id)",
+      update: "Update an existing booking"
+    },
+    filters: {
+      person_id: "Filter by person",
+      service_id: "Filter by service",
+      after: "Filter bookings after date (YYYY-MM-DD)",
+      before: "Filter bookings before date (YYYY-MM-DD)"
+    },
+    includes: ["person", "service", "event"],
+    fields: {
+      id: "Unique booking identifier",
+      started_on: "Start date (YYYY-MM-DD)",
+      ended_on: "End date (YYYY-MM-DD)",
+      time: "Time per day in minutes",
+      total_time: "Total booked time in minutes",
+      note: "Booking note"
+    },
+    examples: [
+      {
+        description: "List my bookings",
+        params: { resource: "bookings", action: "list", filter: { person_id: "me" } }
+      }
+    ]
+  },
+  reports: {
+    description: "Generate various reports (time, budget, project, etc.)",
+    actions: {
+      get: "Generate a report (requires report_type)"
+    },
+    filters: {
+      person_id: "Filter by person",
+      project_id: "Filter by project",
+      company_id: "Filter by company",
+      after: "Filter from date (YYYY-MM-DD)",
+      before: "Filter to date (YYYY-MM-DD)"
+    },
+    fields: {
+      report_type: "Type of report: time_reports, project_reports, budget_reports, person_reports, invoice_reports, payment_reports, service_reports, task_reports, company_reports, deal_reports, timesheet_reports",
+      group: "Grouping dimension (varies by report type)",
+      from: "Start date for date range",
+      to: "End date for date range"
+    },
+    examples: [
+      {
+        description: "Time report by person",
+        params: {
+          resource: "reports",
+          action: "get",
+          report_type: "time_reports",
+          group: "person",
+          from: "2024-01-01",
+          to: "2024-01-31"
+        }
+      },
+      {
+        description: "Project budget report",
+        params: {
+          resource: "reports",
+          action: "get",
+          report_type: "budget_reports",
+          filter: { project_id: "12345" }
+        }
+      }
+    ]
+  }
+};
+function handleHelp(resource) {
+  const help = RESOURCE_HELP[resource];
+  if (!help) {
+    return jsonResult({
+      error: `Unknown resource: ${resource}`,
+      available_resources: Object.keys(RESOURCE_HELP)
+    });
+  }
+  return jsonResult({
+    resource,
+    ...help
+  });
+}
+function handleHelpOverview() {
+  const overview = Object.entries(RESOURCE_HELP).map(([resource, help]) => ({
+    resource,
+    description: help.description,
+    actions: Object.keys(help.actions)
+  }));
+  return jsonResult({
+    message: 'Use action="help" with a specific resource for detailed documentation',
+    resources: overview
+  });
+}
+const VALID_ACTIONS$6 = ["list", "get", "me"];
+async function handlePeople(action, args, ctx, credentials) {
+  const { api, formatOptions, filter, page, perPage } = ctx;
+  const { id } = args;
+  if (action === "get") {
+    if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+    const result = await api.getPerson(id);
+    return jsonResult(formatPerson(result.data, formatOptions));
+  }
+  if (action === "me") {
+    if (credentials.userId) {
+      const result = await api.getPerson(credentials.userId);
+      return jsonResult(formatPerson(result.data, formatOptions));
+    }
+    return jsonResult({
+      message: "User ID not configured. Set userId in credentials to use this action.",
+      hint: 'Use action="list" to find people, or configure the user ID in your credentials.',
+      organizationId: credentials.organizationId
+    });
+  }
+  if (action === "list") {
+    const result = await api.getPeople({ filter, page, perPage });
+    return jsonResult(formatListResponse(result.data, formatPerson, result.meta, formatOptions));
+  }
+  return inputErrorResult(ErrorMessages.invalidAction(action, "people", VALID_ACTIONS$6));
+}
+const VALID_ACTIONS$5 = ["list", "get"];
+async function handleProjects(action, args, ctx) {
+  const { api, formatOptions, filter, page, perPage } = ctx;
+  const { id } = args;
+  if (action === "get") {
+    if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+    const result = await api.getProject(id);
+    return jsonResult(formatProject(result.data, formatOptions));
+  }
+  if (action === "list") {
+    const result = await api.getProjects({ filter, page, perPage });
+    return jsonResult(formatListResponse(result.data, formatProject, result.meta, formatOptions));
+  }
+  return inputErrorResult(ErrorMessages.invalidAction(action, "projects", VALID_ACTIONS$5));
+}
+function formatReportData(data) {
+  return data.map((item) => {
+    const record = item;
+    return {
+      id: record.id,
+      type: record.type,
+      ...record.attributes
+    };
+  });
+}
+const VALID_REPORT_TYPES = [
+  "time_reports",
+  "project_reports",
+  "budget_reports",
+  "person_reports",
+  "invoice_reports",
+  "payment_reports",
+  "service_reports",
+  "task_reports",
+  "company_reports",
+  "deal_reports",
+  "timesheet_reports"
+];
+const VALID_ACTIONS$4 = ["get"];
+async function handleReports(action, args, ctx) {
+  const { api, filter, page, perPage } = ctx;
+  const { report_type, group, from, to, person_id, project_id, company_id, deal_id, status } = args;
+  if (action !== "get") {
+    return inputErrorResult(ErrorMessages.invalidAction(action, "reports", VALID_ACTIONS$4));
+  }
+  if (!report_type) {
+    return inputErrorResult(ErrorMessages.missingReportType());
+  }
+  if (!VALID_REPORT_TYPES.includes(report_type)) {
+    return inputErrorResult(ErrorMessages.invalidReportType(report_type, VALID_REPORT_TYPES));
+  }
+  const reportFilter = { ...filter };
+  if (from) {
+    if (report_type === "invoice_reports") {
+      reportFilter.invoice_date_after = from;
+    } else if (report_type === "payment_reports" || report_type === "deal_reports") {
+      reportFilter.date_after = from;
+    } else {
+      reportFilter.after = from;
+    }
+  }
+  if (to) {
+    if (report_type === "invoice_reports") {
+      reportFilter.invoice_date_before = to;
+    } else if (report_type === "payment_reports" || report_type === "deal_reports") {
+      reportFilter.date_before = to;
+    } else {
+      reportFilter.before = to;
+    }
+  }
+  if (person_id) {
+    if (report_type === "task_reports") {
+      reportFilter.assignee_id = person_id;
+    } else {
+      reportFilter.person_id = person_id;
+    }
+  }
+  if (project_id) reportFilter.project_id = project_id;
+  if (company_id) reportFilter.company_id = company_id;
+  if (deal_id) {
+    if (report_type === "deal_reports") {
+      reportFilter.deal_status_id = deal_id;
+    } else {
+      reportFilter.deal_id = deal_id;
+    }
+  }
+  if (status) {
+    if (report_type === "deal_reports") {
+      reportFilter.deal_status_id = status;
+    } else {
+      reportFilter.status = status;
+    }
+  }
+  let effectiveGroup = group;
+  if (!effectiveGroup) {
+    const defaultGroups = {
+      time_reports: "person",
+      project_reports: "project",
+      budget_reports: "deal",
+      person_reports: "person",
+      invoice_reports: "invoice",
+      payment_reports: "payment",
+      service_reports: "service",
+      task_reports: "task",
+      company_reports: "company",
+      deal_reports: "deal"
+    };
+    effectiveGroup = defaultGroups[report_type];
+  }
+  const includeMap = {
+    project_reports: ["project"],
+    budget_reports: ["deal"],
+    person_reports: ["person"],
+    invoice_reports: ["invoice"],
+    payment_reports: ["payment"],
+    service_reports: ["service"],
+    task_reports: ["task"],
+    company_reports: ["company"],
+    deal_reports: ["deal"],
+    timesheet_reports: ["person"]
+  };
+  const include = includeMap[report_type];
+  const result = await api.getReports(report_type, {
+    page,
+    perPage,
+    filter: reportFilter,
+    group: effectiveGroup,
+    include
+  });
+  const formattedData = formatReportData(result.data);
+  return jsonResult({
+    data: formattedData,
+    meta: result.meta
+  });
+}
+const VALID_ACTIONS$3 = ["list"];
+async function handleServices(action, _args, ctx) {
+  const { api, formatOptions, filter, page, perPage } = ctx;
+  if (action === "list") {
+    const result = await api.getServices({ filter, page, perPage });
+    return jsonResult(formatListResponse(result.data, formatService, result.meta, formatOptions));
+  }
+  return inputErrorResult(ErrorMessages.invalidAction(action, "services", VALID_ACTIONS$3));
+}
+const DEFAULT_TASK_INCLUDE = ["project", "project.company"];
+const VALID_ACTIONS$2 = ["list", "get", "create", "update"];
+async function handleTasks(action, args, ctx) {
+  const { api, formatOptions, filter, page, perPage, include: userInclude } = ctx;
+  const { id, title, project_id, task_list_id, description, assignee_id } = args;
+  const include = userInclude?.length ? [.../* @__PURE__ */ new Set([...DEFAULT_TASK_INCLUDE, ...userInclude])] : DEFAULT_TASK_INCLUDE;
+  if (action === "get") {
+    if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+    const result = await api.getTask(id, { include });
+    return jsonResult(formatTask(result.data, { ...formatOptions, included: result.included }));
+  }
+  if (action === "create") {
+    if (!title || !project_id || !task_list_id) {
+      return inputErrorResult(
+        ErrorMessages.missingRequiredFields("task", ["title", "project_id", "task_list_id"])
+      );
+    }
+    const result = await api.createTask({
+      title,
+      project_id,
+      task_list_id,
+      assignee_id,
+      description
+    });
+    return jsonResult({ success: true, ...formatTask(result.data, formatOptions) });
+  }
+  if (action === "update") {
+    if (!id) return inputErrorResult(ErrorMessages.missingId("update"));
+    const updateData = {};
+    if (title !== void 0) updateData.title = title;
+    if (description !== void 0) updateData.description = description;
+    if (assignee_id !== void 0) updateData.assignee_id = assignee_id;
+    const result = await api.updateTask(id, updateData);
+    return jsonResult({ success: true, ...formatTask(result.data, formatOptions) });
+  }
+  if (action === "list") {
+    const result = await api.getTasks({ filter, page, perPage, include });
+    return jsonResult(
+      formatListResponse(result.data, formatTask, result.meta, {
+        ...formatOptions,
+        included: result.included
+      })
+    );
+  }
+  return inputErrorResult(ErrorMessages.invalidAction(action, "tasks", VALID_ACTIONS$2));
+}
+const VALID_ACTIONS$1 = ["list", "get", "create", "update"];
+async function handleTime(action, args, ctx) {
+  const { api, formatOptions, filter, page, perPage } = ctx;
+  const { id, person_id, service_id, task_id, time, date, note } = args;
+  if (action === "get") {
+    if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+    const result = await api.getTimeEntry(id);
+    return jsonResult(formatTimeEntry(result.data, formatOptions));
+  }
+  if (action === "create") {
+    if (!person_id || !service_id || !time || !date) {
+      return inputErrorResult(
+        ErrorMessages.missingRequiredFields("time entry", [
+          "person_id",
+          "service_id",
+          "time",
+          "date"
+        ])
+      );
+    }
+    const result = await api.createTimeEntry({
+      person_id,
+      service_id,
+      time,
+      date,
+      note,
+      task_id
+    });
+    return jsonResult({ success: true, ...formatTimeEntry(result.data, formatOptions) });
+  }
+  if (action === "update") {
+    if (!id) return inputErrorResult(ErrorMessages.missingId("update"));
+    const updateData = {};
+    if (time !== void 0) updateData.time = time;
+    if (date !== void 0) updateData.date = date;
+    if (note !== void 0) updateData.note = note;
+    const result = await api.updateTimeEntry(id, updateData);
+    return jsonResult({ success: true, ...formatTimeEntry(result.data, formatOptions) });
+  }
+  if (action === "list") {
+    const result = await api.getTimeEntries({ filter, page, perPage });
+    return jsonResult(formatListResponse(result.data, formatTimeEntry, result.meta, formatOptions));
+  }
+  return inputErrorResult(ErrorMessages.invalidAction(action, "time", VALID_ACTIONS$1));
+}
+const VALID_ACTIONS = ["list", "get", "start", "stop"];
+async function handleTimers(action, args, ctx) {
+  const { api, formatOptions, filter, page, perPage, include } = ctx;
+  const { id, service_id, time_entry_id } = args;
+  if (action === "get") {
+    if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+    const result = await api.getTimer(id, { include });
+    return jsonResult(formatTimer(result.data));
+  }
+  if (action === "start" || action === "create") {
+    if (!service_id && !time_entry_id) {
+      return inputErrorResult(ErrorMessages.missingServiceForTimer());
+    }
+    const result = await api.startTimer({ service_id, time_entry_id });
+    return jsonResult({ success: true, ...formatTimer(result.data) });
+  }
+  if (action === "stop") {
+    if (!id) return inputErrorResult(ErrorMessages.missingId("stop"));
+    const result = await api.stopTimer(id);
+    return jsonResult({ success: true, ...formatTimer(result.data) });
+  }
+  if (action === "list") {
+    const result = await api.getTimers({ filter, page, perPage, include });
+    return jsonResult(formatListResponse(result.data, formatTimer, result.meta, formatOptions));
+  }
+  return inputErrorResult(ErrorMessages.invalidAction(action, "timers", VALID_ACTIONS));
+}
+const VALID_RESOURCES = [
+  "projects",
+  "time",
+  "tasks",
+  "services",
+  "people",
+  "companies",
+  "comments",
+  "timers",
+  "deals",
+  "bookings",
+  "reports"
+];
+const DEFAULT_PER_PAGE = 20;
+async function executeToolWithCredentials(name, args, credentials) {
+  const api = new ProductiveApi({
+    token: credentials.apiToken,
+    "org-id": credentials.organizationId,
+    "user-id": credentials.userId
+  });
+  if (name !== "productive") {
+    return errorResult(`Unknown tool: ${name}`);
+  }
+  const { resource, action, filter, page, per_page, compact, include, query, ...restArgs } = args;
+  const isCompact = compact ?? action !== "get";
+  const formatOptions = { compact: isCompact };
+  let stringFilter = toStringFilter(filter);
+  const perPage = per_page ?? DEFAULT_PER_PAGE;
+  if (query) {
+    stringFilter = { ...stringFilter, query };
+  }
+  const ctx = {
+    api,
+    formatOptions,
+    filter: stringFilter,
+    page,
+    perPage,
+    include
+  };
+  try {
+    if (action === "help") {
+      return resource ? handleHelp(resource) : handleHelpOverview();
+    }
+    switch (resource) {
+      case "projects":
+        return await handleProjects(action, restArgs, ctx);
+      case "time":
+        return await handleTime(action, restArgs, ctx);
+      case "tasks":
+        return await handleTasks(action, restArgs, ctx);
+      case "services":
+        return await handleServices(action, restArgs, ctx);
+      case "people":
+        return await handlePeople(action, restArgs, ctx, credentials);
+      case "companies":
+        return await handleCompanies(action, restArgs, ctx);
+      case "comments":
+        return await handleComments(action, restArgs, ctx);
+      case "timers":
+        return await handleTimers(action, restArgs, ctx);
+      case "deals":
+        return await handleDeals(action, restArgs, ctx);
+      case "bookings":
+        return await handleBookings(action, restArgs, ctx);
+      case "reports":
+        return await handleReports(action, restArgs, ctx);
+      default:
+        return inputErrorResult(ErrorMessages.unknownResource(resource, VALID_RESOURCES));
+    }
+  } catch (error) {
+    if (isUserInputError(error)) {
+      return formatError(error);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const statusMatch = message.match(/(\d{3})/);
+    if (statusMatch) {
+      const statusCode = Number.parseInt(statusMatch[1], 10);
+      return inputErrorResult(ErrorMessages.apiError(statusCode, message));
+    }
+    return errorResult(message);
+  }
+}
+export {
+  executeToolWithCredentials as e
+};
+//# sourceMappingURL=index-D743zTS1.js.map