planflow-mcp 0.1.0 → 0.1.2

package/dist/index.js

@@ -7,7 +7,753 @@ import {
   CallToolRequestSchema,
   ListToolsRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
-import { APP_NAME, APP_VERSION } from "@planflow/shared";
+
+// ../shared/dist/index.js
+import { z } from "zod";
+var UserSchema = z.object({
+  id: z.string().uuid(),
+  email: z.string().email(),
+  name: z.string().min(1),
+  createdAt: z.date(),
+  updatedAt: z.date()
+});
+var RegisterRequestSchema = z.object({
+  email: z.string().email("Invalid email address"),
+  password: z.string().min(8, "Password must be at least 8 characters").max(72, "Password must be at most 72 characters"),
+  // bcrypt limit
+  name: z.string().min(1, "Name is required").max(100, "Name must be at most 100 characters")
+});
+var LoginRequestSchema = z.object({
+  email: z.string().email("Invalid email address"),
+  password: z.string().min(1, "Password is required")
+});
+var AuthResponseSchema = z.object({
+  user: UserSchema,
+  token: z.string(),
+  refreshToken: z.string(),
+  expiresIn: z.number(),
+  // seconds until access token expires
+  refreshExpiresIn: z.number()
+  // seconds until refresh token expires
+});
+var ForgotPasswordRequestSchema = z.object({
+  email: z.string().email("Invalid email address")
+});
+var RefreshTokenRequestSchema = z.object({
+  refreshToken: z.string().min(1, "Refresh token is required")
+});
+var TokenRefreshResponseSchema = z.object({
+  token: z.string(),
+  expiresIn: z.number()
+});
+var SessionSchema = z.object({
+  id: z.string().uuid(),
+  createdAt: z.date(),
+  expiresAt: z.date(),
+  isCurrent: z.boolean()
+  // true if this is the session making the request
+});
+var SessionsResponseSchema = z.object({
+  sessions: z.array(SessionSchema),
+  total: z.number()
+});
+var LogoutAllResponseSchema = z.object({
+  revokedCount: z.number(),
+  message: z.string()
+});
+var ProjectSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string().min(1),
+  description: z.string().optional(),
+  userId: z.string().uuid(),
+  plan: z.string().optional(),
+  createdAt: z.date(),
+  updatedAt: z.date()
+});
+var CreateProjectRequestSchema = z.object({
+  name: z.string().min(1, "Project name is required").max(255, "Project name must be at most 255 characters"),
+  description: z.string().max(2e3, "Description must be at most 2000 characters").optional(),
+  plan: z.string().optional(),
+  organizationId: z.string().uuid("Invalid organization ID")
+});
+var UpdateProjectRequestSchema = z.object({
+  name: z.string().min(1, "Project name cannot be empty").max(255, "Project name must be at most 255 characters").optional(),
+  description: z.string().max(2e3, "Description must be at most 2000 characters").nullable().optional(),
+  plan: z.string().nullable().optional()
+});
+var TaskStatusSchema = z.enum(["TODO", "IN_PROGRESS", "DONE", "BLOCKED"]);
+var TaskComplexitySchema = z.enum(["Low", "Medium", "High"]);
+var TaskSchema = z.object({
+  id: z.string().uuid(),
+  projectId: z.string().uuid(),
+  taskId: z.string(),
+  // e.g., "T1.1"
+  name: z.string().min(1),
+  description: z.string().optional(),
+  status: TaskStatusSchema,
+  complexity: TaskComplexitySchema,
+  estimatedHours: z.number().positive().optional(),
+  dependencies: z.array(z.string()).default([]),
+  createdAt: z.date(),
+  updatedAt: z.date()
+});
+var CreateTaskRequestSchema = z.object({
+  taskId: z.string().min(1, "Task ID is required"),
+  // e.g., "T1.1"
+  name: z.string().min(1, "Task name is required").max(255, "Task name must be at most 255 characters"),
+  description: z.string().max(2e3, "Description must be at most 2000 characters").optional(),
+  status: TaskStatusSchema.optional().default("TODO"),
+  complexity: TaskComplexitySchema.optional().default("Medium"),
+  estimatedHours: z.number().positive("Estimated hours must be positive").optional(),
+  dependencies: z.array(z.string()).default([])
+});
+var UpdateTaskRequestSchema = z.object({
+  taskId: z.string().min(1).optional(),
+  name: z.string().min(1).max(255).optional(),
+  description: z.string().max(2e3).nullable().optional(),
+  status: TaskStatusSchema.optional(),
+  complexity: TaskComplexitySchema.optional(),
+  estimatedHours: z.number().positive().nullable().optional(),
+  dependencies: z.array(z.string()).optional()
+});
+var BulkUpdateTasksRequestSchema = z.object({
+  tasks: z.array(
+    z.object({
+      id: z.string().uuid("Invalid task ID format"),
+      taskId: z.string().min(1).optional(),
+      name: z.string().min(1).max(255).optional(),
+      description: z.string().max(2e3).nullable().optional(),
+      status: TaskStatusSchema.optional(),
+      complexity: TaskComplexitySchema.optional(),
+      estimatedHours: z.number().positive().nullable().optional(),
+      dependencies: z.array(z.string()).optional()
+    })
+  ).min(1, "At least one task must be provided")
+});
+var BulkAssignTasksRequestSchema = z.object({
+  taskIds: z.array(z.string().uuid("Invalid task ID format")).min(1, "At least one task must be provided").max(100, "Maximum 100 tasks allowed"),
+  assigneeId: z.string().uuid("Invalid assignee ID format").nullable()
+});
+var BulkDeleteTasksRequestSchema = z.object({
+  taskIds: z.array(z.string().uuid("Invalid task ID format")).min(1, "At least one task must be provided").max(100, "Maximum 100 tasks allowed")
+});
+var BulkStatusUpdateRequestSchema = z.object({
+  taskIds: z.array(z.string().uuid("Invalid task ID format")).min(1, "At least one task must be provided").max(100, "Maximum 100 tasks allowed"),
+  status: TaskStatusSchema
+});
+var ApiTokenSchema = z.object({
+  id: z.string().uuid(),
+  userId: z.string().uuid(),
+  name: z.string().min(1),
+  lastUsedAt: z.date().nullable(),
+  expiresAt: z.date().nullable(),
+  isRevoked: z.boolean(),
+  createdAt: z.date()
+});
+var CreateApiTokenRequestSchema = z.object({
+  name: z.string().min(1, "Token name is required").max(100, "Token name must be at most 100 characters"),
+  expiresInDays: z.number().int().min(1, "Expiration must be at least 1 day").max(365, "Expiration must be at most 365 days").optional()
+});
+var UpdateProfileRequestSchema = z.object({
+  name: z.string().min(1, "Name is required").max(100, "Name must be at most 100 characters").optional(),
+  email: z.string().email("Invalid email address").optional()
+});
+var ChangePasswordRequestSchema = z.object({
+  currentPassword: z.string().min(1, "Current password is required"),
+  newPassword: z.string().min(8, "New password must be at least 8 characters").max(72, "New password must be at most 72 characters")
+});
+var SubscriptionTierSchema = z.enum(["free", "pro", "team", "enterprise"]);
+var SubscriptionStatusSchema = z.enum(["active", "canceled", "past_due", "trialing"]);
+var SubscriptionSchema = z.object({
+  id: z.string().uuid(),
+  userId: z.string().uuid(),
+  tier: SubscriptionTierSchema,
+  status: SubscriptionStatusSchema,
+  lemonSqueezyCustomerId: z.string().nullable(),
+  lemonSqueezySubscriptionId: z.string().nullable(),
+  currentPeriodStart: z.date().nullable(),
+  currentPeriodEnd: z.date().nullable(),
+  canceledAt: z.date().nullable(),
+  createdAt: z.date(),
+  updatedAt: z.date()
+});
+var CreateCheckoutRequestSchema = z.object({
+  tier: z.enum(["pro", "team"], {
+    required_error: "Tier is required",
+    invalid_type_error: 'Tier must be either "pro" or "team"'
+  })
+});
+var CheckoutResponseSchema = z.object({
+  checkoutUrl: z.string().url()
+});
+var ProjectLimitsSchema = z.object({
+  currentCount: z.number(),
+  maxProjects: z.number(),
+  // -1 = unlimited
+  canCreate: z.boolean(),
+  tier: SubscriptionTierSchema,
+  status: SubscriptionStatusSchema
+});
+var FeedbackCategorySchema = z.enum(["general", "bug", "feature", "usability", "performance"]);
+var FeedbackSchema = z.object({
+  id: z.string().uuid(),
+  userId: z.string().uuid(),
+  category: FeedbackCategorySchema,
+  rating: z.number().int().min(1).max(5),
+  message: z.string(),
+  userAgent: z.string().nullable(),
+  pageUrl: z.string().nullable(),
+  createdAt: z.date()
+});
+var CreateFeedbackRequestSchema = z.object({
+  category: FeedbackCategorySchema.default("general"),
+  rating: z.number().int("Rating must be a whole number").min(1, "Rating must be at least 1").max(5, "Rating must be at most 5"),
+  message: z.string().min(10, "Please provide at least 10 characters of feedback").max(5e3, "Feedback must be at most 5000 characters"),
+  pageUrl: z.string().url().optional()
+});
+var OrgMemberRoleSchema = z.enum(["owner", "admin", "editor", "viewer"]);
+var OrganizationSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string().min(1),
+  slug: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
+  description: z.string().nullable().optional(),
+  createdBy: z.string().uuid(),
+  createdAt: z.date(),
+  updatedAt: z.date()
+});
+var OrganizationMemberSchema = z.object({
+  id: z.string().uuid(),
+  organizationId: z.string().uuid(),
+  userId: z.string().uuid(),
+  role: OrgMemberRoleSchema,
+  createdAt: z.date(),
+  updatedAt: z.date()
+});
+var CreateOrganizationRequestSchema = z.object({
+  name: z.string().min(1, "Organization name is required").max(255, "Organization name must be at most 255 characters"),
+  slug: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Slug must be lowercase alphanumeric with hyphens").max(255, "Slug must be at most 255 characters").optional(),
+  description: z.string().max(2e3, "Description must be at most 2000 characters").optional()
+});
+var UpdateOrganizationRequestSchema = z.object({
+  name: z.string().min(1, "Organization name cannot be empty").max(255, "Organization name must be at most 255 characters").optional(),
+  slug: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Slug must be lowercase alphanumeric with hyphens").max(255, "Slug must be at most 255 characters").optional(),
+  description: z.string().max(2e3, "Description must be at most 2000 characters").nullable().optional()
+});
+var CreateInvitationRequestSchema = z.object({
+  email: z.string().email("Invalid email address"),
+  role: z.enum(["admin", "editor", "viewer"]).optional().default("editor")
+});
+var InvitationSchema = z.object({
+  id: z.string().uuid(),
+  organizationId: z.string().uuid(),
+  email: z.string().email(),
+  role: OrgMemberRoleSchema,
+  invitedBy: z.string().uuid(),
+  token: z.string(),
+  expiresAt: z.date(),
+  acceptedAt: z.date().nullable(),
+  createdAt: z.date()
+});
+var UpdateMemberRoleRequestSchema = z.object({
+  role: z.enum(["admin", "editor", "viewer"], {
+    required_error: "Role is required",
+    invalid_type_error: "Role must be admin, editor, or viewer"
+  })
+});
+var ProjectMemberRoleSchema = z.enum(["owner", "editor", "viewer"]);
+var ProjectMemberSchema = z.object({
+  id: z.string().uuid(),
+  projectId: z.string().uuid(),
+  userId: z.string().uuid(),
+  role: ProjectMemberRoleSchema,
+  invitedBy: z.string().uuid().nullable(),
+  createdAt: z.date(),
+  updatedAt: z.date()
+});
+var ProjectMemberWithUserSchema = ProjectMemberSchema.extend({
+  userName: z.string().nullable(),
+  userEmail: z.string().email()
+});
+var CreateProjectInvitationRequestSchema = z.object({
+  email: z.string().email("Invalid email address"),
+  role: z.enum(["editor", "viewer"]).optional().default("editor")
+});
+var ProjectInvitationSchema = z.object({
+  id: z.string().uuid(),
+  projectId: z.string().uuid(),
+  email: z.string().email(),
+  role: ProjectMemberRoleSchema,
+  invitedBy: z.string().uuid(),
+  token: z.string(),
+  expiresAt: z.date(),
+  acceptedAt: z.date().nullable(),
+  createdAt: z.date()
+});
+var ProjectInvitationWithDetailsSchema = ProjectInvitationSchema.extend({
+  inviterName: z.string().nullable(),
+  projectName: z.string(),
+  organizationName: z.string()
+});
+var UpdateProjectMemberRoleRequestSchema = z.object({
+  role: z.enum(["editor", "viewer"], {
+    required_error: "Role is required",
+    invalid_type_error: "Role must be editor or viewer"
+  })
+});
+var AssignTaskRequestSchema = z.object({
+  assigneeId: z.string().uuid("Invalid user ID format")
+});
+var TaskAssignmentSchema = z.object({
+  taskId: z.string(),
+  assigneeId: z.string().uuid().nullable(),
+  assignedBy: z.string().uuid().nullable(),
+  assignedAt: z.date().nullable()
+});
+var TaskWithAssigneeSchema = TaskSchema.extend({
+  assigneeId: z.string().uuid().nullable(),
+  assignedBy: z.string().uuid().nullable(),
+  assignedAt: z.date().nullable(),
+  assignee: z.object({
+    id: z.string().uuid(),
+    email: z.string().email(),
+    name: z.string().nullable()
+  }).nullable().optional()
+});
+var CommentSchema = z.object({
+  id: z.string().uuid(),
+  taskId: z.string().uuid(),
+  authorId: z.string().uuid(),
+  content: z.string().min(1),
+  parentId: z.string().uuid().nullable(),
+  mentions: z.array(z.string().uuid()).nullable(),
+  createdAt: z.date(),
+  updatedAt: z.date()
+});
+var CreateCommentRequestSchema = z.object({
+  content: z.string().min(1, "Comment content is required").max(1e4, "Comment must be at most 10000 characters"),
+  parentId: z.string().uuid("Invalid parent comment ID").optional(),
+  mentions: z.array(z.string().uuid("Invalid user ID in mentions")).optional()
+});
+var UpdateCommentRequestSchema = z.object({
+  content: z.string().min(1, "Comment content cannot be empty").max(1e4, "Comment must be at most 10000 characters").optional(),
+  mentions: z.array(z.string().uuid("Invalid user ID in mentions")).optional()
+});
+var CommentAuthorSchema = z.object({
+  id: z.string().uuid(),
+  email: z.string().email(),
+  name: z.string().nullable()
+});
+var CommentWithAuthorSchema = CommentSchema.extend({
+  author: CommentAuthorSchema
+});
+var ActivityActionSchema = z.enum([
+  "task_created",
+  "task_updated",
+  "task_deleted",
+  "task_status_changed",
+  "task_assigned",
+  "task_unassigned",
+  "comment_created",
+  "comment_updated",
+  "comment_deleted",
+  "project_created",
+  "project_updated",
+  "project_deleted",
+  "plan_updated",
+  "member_invited",
+  "member_joined",
+  "member_removed",
+  "member_role_changed",
+  "other"
+]);
+var ActivityEntitySchema = z.enum([
+  "task",
+  "comment",
+  "project",
+  "organization",
+  "member",
+  "invitation"
+]);
+var ActivityMetadataSchema = z.record(z.unknown()).optional();
+var ActivityLogSchema = z.object({
+  id: z.string().uuid(),
+  action: ActivityActionSchema,
+  entityType: ActivityEntitySchema,
+  entityId: z.string().uuid().nullable(),
+  taskId: z.string().nullable(),
+  // Human-readable task ID like "T1.1"
+  actorId: z.string().uuid(),
+  organizationId: z.string().uuid().nullable(),
+  projectId: z.string().uuid().nullable(),
+  taskUuid: z.string().uuid().nullable(),
+  metadata: ActivityMetadataSchema,
+  description: z.string().nullable(),
+  createdAt: z.date()
+});
+var ActivityActorSchema = z.object({
+  id: z.string().uuid(),
+  email: z.string().email(),
+  name: z.string().nullable()
+});
+var ActivityLogWithActorSchema = ActivityLogSchema.extend({
+  actor: ActivityActorSchema
+});
+var ActivityLogQuerySchema = z.object({
+  limit: z.coerce.number().int().min(1).max(100).optional().default(50),
+  offset: z.coerce.number().int().min(0).optional().default(0),
+  action: ActivityActionSchema.optional(),
+  entityType: ActivityEntitySchema.optional(),
+  actorId: z.string().uuid().optional(),
+  taskId: z.string().optional()
+  // Human-readable task ID filter
+});
+var CreateActivityLogRequestSchema = z.object({
+  action: ActivityActionSchema,
+  entityType: ActivityEntitySchema,
+  entityId: z.string().uuid().optional(),
+  taskId: z.string().optional(),
+  organizationId: z.string().uuid().optional(),
+  projectId: z.string().uuid().optional(),
+  taskUuid: z.string().uuid().optional(),
+  metadata: ActivityMetadataSchema,
+  description: z.string().max(1e3).optional()
+});
+var WebSocketMessageSchema = z.object({
+  type: z.string(),
+  projectId: z.string().uuid(),
+  timestamp: z.string().datetime(),
+  data: z.record(z.unknown()).optional()
+});
+var WebSocketEventTypeSchema = z.enum([
+  "connected",
+  "task_updated",
+  "task_assigned",
+  "task_unassigned",
+  "tasks_synced",
+  "project_updated",
+  "ping",
+  "pong",
+  // Presence events (T5.9)
+  "presence_joined",
+  "presence_left",
+  "presence_updated",
+  "presence_list"
+]);
+var WebSocketTaskDataSchema = z.object({
+  id: z.string().uuid(),
+  taskId: z.string(),
+  name: z.string(),
+  description: z.string().nullable(),
+  status: z.string(),
+  complexity: z.string().nullable(),
+  estimatedHours: z.number().nullable(),
+  dependencies: z.array(z.string()),
+  assigneeId: z.string().uuid().nullable().optional(),
+  assignedBy: z.string().uuid().nullable().optional(),
+  assignedAt: z.coerce.date().nullable().optional(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date()
+});
+var WebSocketUserInfoSchema = z.object({
+  id: z.string().uuid(),
+  email: z.string().email(),
+  name: z.string().nullable()
+});
+var ConnectedEventDataSchema = z.object({
+  userId: z.string().uuid(),
+  projectName: z.string()
+});
+var TaskUpdatedEventDataSchema = z.object({
+  task: WebSocketTaskDataSchema
+});
+var TaskAssignedEventDataSchema = z.object({
+  task: WebSocketTaskDataSchema,
+  assignee: WebSocketUserInfoSchema.nullable(),
+  assignedBy: WebSocketUserInfoSchema
+});
+var TaskUnassignedEventDataSchema = z.object({
+  task: WebSocketTaskDataSchema,
+  previousAssigneeId: z.string().uuid().nullable(),
+  unassignedBy: WebSocketUserInfoSchema
+});
+var TasksSyncedEventDataSchema = z.object({
+  tasksCount: z.number(),
+  completedCount: z.number(),
+  progress: z.number()
+});
+var ProjectUpdatedEventDataSchema = z.object({
+  updatedFields: z.object({
+    name: z.string().optional(),
+    description: z.string().nullable().optional(),
+    updatedAt: z.string().datetime()
+  })
+});
+var PresenceStatusSchema = z.enum(["online", "idle", "away"]);
+var UserPresenceSchema = z.object({
+  userId: z.string().uuid(),
+  email: z.string().email(),
+  name: z.string().nullable(),
+  status: PresenceStatusSchema,
+  connectedAt: z.string().datetime(),
+  lastActiveAt: z.string().datetime()
+});
+var PresenceJoinedEventDataSchema = z.object({
+  user: UserPresenceSchema,
+  onlineCount: z.number().int().min(0)
+});
+var PresenceLeftEventDataSchema = z.object({
+  userId: z.string().uuid(),
+  onlineCount: z.number().int().min(0)
+});
+var PresenceUpdatedEventDataSchema = z.object({
+  userId: z.string().uuid(),
+  status: PresenceStatusSchema,
+  lastActiveAt: z.string().datetime()
+});
+var PresenceListEventDataSchema = z.object({
+  users: z.array(UserPresenceSchema),
+  onlineCount: z.number().int().min(0)
+});
+var NotificationTypeSchema = z.enum([
+  "mention",
+  "assignment",
+  "unassignment",
+  "comment",
+  "comment_reply",
+  "status_change",
+  "task_created",
+  "task_deleted",
+  "invitation",
+  "member_joined",
+  "member_removed",
+  "role_changed"
+]);
+var NotificationSchema = z.object({
+  id: z.string().uuid(),
+  userId: z.string().uuid(),
+  type: NotificationTypeSchema,
+  title: z.string().min(1).max(255),
+  body: z.string().nullable(),
+  link: z.string().max(500).nullable(),
+  projectId: z.string().uuid().nullable(),
+  organizationId: z.string().uuid().nullable(),
+  actorId: z.string().uuid().nullable(),
+  taskId: z.string().nullable(),
+  readAt: z.date().nullable(),
+  createdAt: z.date()
+});
+var NotificationActorSchema = z.object({
+  id: z.string().uuid(),
+  email: z.string().email(),
+  name: z.string().nullable()
+});
+var NotificationWithActorSchema = NotificationSchema.extend({
+  actor: NotificationActorSchema.nullable()
+});
+var NotificationsQuerySchema = z.object({
+  limit: z.coerce.number().int().min(1).max(100).optional().default(50),
+  offset: z.coerce.number().int().min(0).optional().default(0),
+  unreadOnly: z.coerce.boolean().optional().default(false),
+  type: NotificationTypeSchema.optional(),
+  projectId: z.string().uuid().optional()
+});
+var MarkNotificationsReadRequestSchema = z.object({
+  notificationIds: z.array(z.string().uuid()).min(1).max(100)
+});
+var CreateNotificationRequestSchema = z.object({
+  userId: z.string().uuid(),
+  type: NotificationTypeSchema,
+  title: z.string().min(1).max(255),
+  body: z.string().max(2e3).optional(),
+  link: z.string().max(500).optional(),
+  projectId: z.string().uuid().optional(),
+  organizationId: z.string().uuid().optional(),
+  actorId: z.string().uuid().optional(),
+  taskId: z.string().optional()
+});
+var GitHubAuthorizationResponseSchema = z.object({
+  authorizationUrl: z.string().url(),
+  state: z.string()
+});
+var GitHubCallbackRequestSchema = z.object({
+  code: z.string().min(1, "Authorization code is required"),
+  state: z.string().min(1, "State token is required")
+});
+var GitHubIntegrationSchema = z.object({
+  id: z.string().uuid(),
+  githubId: z.string(),
+  githubUsername: z.string(),
+  githubEmail: z.string().nullable(),
+  githubAvatarUrl: z.string().nullable(),
+  githubName: z.string().nullable(),
+  grantedScopes: z.array(z.string()).nullable(),
+  isConnected: z.boolean(),
+  lastSyncAt: z.date().nullable(),
+  createdAt: z.date(),
+  updatedAt: z.date()
+});
+var GitHubUserInfoSchema = z.object({
+  id: z.number(),
+  login: z.string(),
+  name: z.string().nullable(),
+  email: z.string().nullable(),
+  avatar_url: z.string().nullable()
+});
+var GitHubRepositorySchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  full_name: z.string(),
+  owner: z.object({
+    login: z.string(),
+    avatar_url: z.string().nullable()
+  }),
+  description: z.string().nullable(),
+  private: z.boolean(),
+  html_url: z.string().url(),
+  default_branch: z.string()
+});
+var GitHubIssueSchema = z.object({
+  id: z.number(),
+  number: z.number(),
+  title: z.string(),
+  body: z.string().nullable(),
+  state: z.enum(["open", "closed"]),
+  html_url: z.string().url(),
+  created_at: z.string().datetime(),
+  updated_at: z.string().datetime(),
+  closed_at: z.string().datetime().nullable(),
+  user: z.object({
+    login: z.string(),
+    avatar_url: z.string().nullable()
+  }),
+  labels: z.array(z.object({
+    id: z.number(),
+    name: z.string(),
+    color: z.string()
+  })),
+  assignees: z.array(z.object({
+    login: z.string(),
+    avatar_url: z.string().nullable()
+  }))
+});
+var TaskGitHubLinkSchema = z.object({
+  issueNumber: z.number(),
+  repository: z.string(),
+  // "owner/repo"
+  issueUrl: z.string().url(),
+  issueTitle: z.string(),
+  issueState: z.enum(["open", "closed"]),
+  linkedBy: z.string().uuid(),
+  linkedAt: z.date()
+});
+var LinkTaskToGitHubRequestSchema = z.object({
+  issueNumber: z.number().int().positive("Issue number must be positive"),
+  repository: z.string().regex(/^[^/]+\/[^/]+$/, 'Repository must be in format "owner/repo"')
+});
+var CreateGitHubIssueFromTaskRequestSchema = z.object({
+  repository: z.string().regex(/^[^/]+\/[^/]+$/, 'Repository must be in format "owner/repo"'),
+  labels: z.array(z.string()).optional(),
+  assignees: z.array(z.string()).optional()
+});
+var GitHubIssuesQuerySchema = z.object({
+  state: z.enum(["open", "closed", "all"]).optional().default("open"),
+  page: z.coerce.number().int().min(1).optional().default(1),
+  perPage: z.coerce.number().int().min(1).max(100).optional().default(30),
+  search: z.string().optional()
+});
+var TaskWithGitHubLinkSchema = TaskSchema.extend({
+  assigneeId: z.string().uuid().nullable(),
+  assignedBy: z.string().uuid().nullable(),
+  assignedAt: z.date().nullable(),
+  assignee: z.object({
+    id: z.string().uuid(),
+    email: z.string().email(),
+    name: z.string().nullable()
+  }).nullable().optional(),
+  githubIssueNumber: z.number().nullable(),
+  githubRepository: z.string().nullable(),
+  githubIssueUrl: z.string().nullable(),
+  githubIssueTitle: z.string().nullable(),
+  githubIssueState: z.enum(["open", "closed"]).nullable(),
+  githubLinkedBy: z.string().uuid().nullable(),
+  githubLinkedAt: z.date().nullable()
+});
+var GitHubPrStateSchema = z.enum(["open", "closed", "merged"]);
+var GitHubPullRequestSchema = z.object({
+  id: z.number(),
+  number: z.number(),
+  title: z.string(),
+  body: z.string().nullable(),
+  state: GitHubPrStateSchema,
+  draft: z.boolean(),
+  html_url: z.string().url(),
+  created_at: z.string().datetime(),
+  updated_at: z.string().datetime(),
+  closed_at: z.string().datetime().nullable(),
+  merged_at: z.string().datetime().nullable(),
+  user: z.object({
+    login: z.string(),
+    avatar_url: z.string().nullable()
+  }),
+  head: z.object({
+    ref: z.string(),
+    // Branch name
+    sha: z.string()
+  }),
+  base: z.object({
+    ref: z.string(),
+    // Target branch (e.g., "main")
+    sha: z.string()
+  }),
+  labels: z.array(z.object({
+    id: z.number(),
+    name: z.string(),
+    color: z.string()
+  })),
+  assignees: z.array(z.object({
+    login: z.string(),
+    avatar_url: z.string().nullable()
+  })),
+  requested_reviewers: z.array(z.object({
+    login: z.string(),
+    avatar_url: z.string().nullable()
+  }))
+});
+var TaskGitHubPrLinkSchema = z.object({
+  prNumber: z.number(),
+  repository: z.string(),
+  // "owner/repo"
+  prUrl: z.string().url(),
+  prTitle: z.string(),
+  prState: GitHubPrStateSchema,
+  headBranch: z.string(),
+  baseBranch: z.string(),
+  linkedBy: z.string().uuid(),
+  linkedAt: z.date()
+});
+var LinkTaskToGitHubPrRequestSchema = z.object({
+  prNumber: z.number().int().positive("PR number must be positive"),
+  repository: z.string().regex(/^[^/]+\/[^/]+$/, 'Repository must be in format "owner/repo"')
+});
+var GitHubPullRequestsQuerySchema = z.object({
+  state: z.enum(["open", "closed", "all"]).optional().default("open"),
+  page: z.coerce.number().int().min(1).optional().default(1),
+  perPage: z.coerce.number().int().min(1).max(100).optional().default(30),
+  search: z.string().optional()
+});
+var TaskWithGitHubPrLinkSchema = TaskWithGitHubLinkSchema.extend({
+  githubPrNumber: z.number().nullable(),
+  githubPrRepository: z.string().nullable(),
+  githubPrUrl: z.string().nullable(),
+  githubPrTitle: z.string().nullable(),
+  githubPrState: GitHubPrStateSchema.nullable(),
+  githubPrBranch: z.string().nullable(),
+  githubPrBaseBranch: z.string().nullable(),
+  githubPrLinkedBy: z.string().uuid().nullable(),
+  githubPrLinkedAt: z.date().nullable()
+});
+var APP_NAME = "PlanFlow";
+var APP_VERSION = "0.0.1";
 
 // src/errors.ts
 var PlanFlowError = class extends Error {
@@ -109,18 +855,18 @@ var Logger = class {
 var logger = new Logger();
 
 // src/tools/login.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/config.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
-import { z } from "zod";
-var ConfigSchema = z.object({
-  apiToken: z.string().optional(),
-  apiUrl: z.string().url().default("https://api.planflow.tools"),
-  userId: z.string().uuid().optional(),
-  userEmail: z.string().email().optional()
+import { z as z2 } from "zod";
+var ConfigSchema = z2.object({
+  apiToken: z2.string().optional(),
+  apiUrl: z2.string().url().default("https://api.planflow.tools"),
+  userId: z2.string().uuid().optional(),
+  userEmail: z2.string().email().optional()
 });
 var DEFAULT_CONFIG = {
   apiUrl: "https://api.planflow.tools"
@@ -152,7 +898,7 @@ function loadConfig() {
     logger.debug("Loaded config from disk");
     return config;
   } catch (error) {
-    if (error instanceof z.ZodError) {
+    if (error instanceof z2.ZodError) {
       logger.warn("Invalid config file, using defaults", { errors: error.errors });
       return DEFAULT_CONFIG;
     }
@@ -390,11 +1136,33 @@ var ApiClient = class {
   // ============================================================
   // Project Endpoints
   // ============================================================
+  /**
+   * List all organizations for the authenticated user
+   */
+  async listOrganizations() {
+    const response = await this.request("GET", "/organizations");
+    return response.organizations;
+  }
+  /**
+   * Get the user's default organization (first one they own or are a member of)
+   */
+  async getDefaultOrganization() {
+    const orgs = await this.listOrganizations();
+    return orgs.find((o) => o.role === "owner") || orgs[0] || null;
+  }
   /**
    * List all projects for the authenticated user
    */
-  async listProjects() {
-    const response = await this.request("GET", "/projects");
+  async listProjects(organizationId) {
+    let orgId = organizationId;
+    if (!orgId) {
+      const defaultOrg = await this.getDefaultOrganization();
+      if (!defaultOrg) {
+        throw new ApiError("No organization found. Please create an organization first.", 400);
+      }
+      orgId = defaultOrg.id;
+    }
+    const response = await this.request("GET", `/projects?organizationId=${orgId}`);
     return response.projects;
   }
   /**
@@ -689,8 +1457,8 @@ function formatKeyValue(pairs) {
 }
 
 // src/tools/login.ts
-var LoginInputSchema = z2.object({
-  token: z2.string().min(1, "API token is required")
+var LoginInputSchema = z3.object({
+  token: z3.string().min(1, "API token is required")
 });
 var loginTool = {
   name: "planflow_login",
@@ -759,8 +1527,8 @@ Please check your internet connection and try again.`
 };
 
 // src/tools/logout.ts
-import { z as z3 } from "zod";
-var LogoutInputSchema = z3.object({});
+import { z as z4 } from "zod";
+var LogoutInputSchema = z4.object({});
 var logoutTool = {
   name: "planflow_logout",
   description: `Log out from PlanFlow and clear stored credentials.
@@ -812,8 +1580,8 @@ Please try again or manually delete the config file at:
 };
 
 // src/tools/whoami.ts
-import { z as z4 } from "zod";
-var WhoamiInputSchema = z4.object({});
+import { z as z5 } from "zod";
+var WhoamiInputSchema = z5.object({});
 function formatDate(date) {
   const d = typeof date === "string" ? new Date(date) : date;
   return d.toLocaleDateString("en-US", {
@@ -896,8 +1664,8 @@ Please try again or check your connection.`
 };
 
 // src/tools/projects.ts
-import { z as z5 } from "zod";
-var ProjectsInputSchema = z5.object({});
+import { z as z6 } from "zod";
+var ProjectsInputSchema = z6.object({});
 function formatDate2(date) {
   const d = typeof date === "string" ? new Date(date) : date;
   return d.toLocaleDateString("en-US", {
@@ -999,10 +1767,10 @@ Please try again or check your connection.`
 };
 
 // src/tools/create.ts
-import { z as z6 } from "zod";
-var CreateInputSchema = z6.object({
-  name: z6.string().min(1, "Project name is required").max(255, "Project name must be at most 255 characters"),
-  description: z6.string().max(1e3, "Description must be at most 1000 characters").optional()
+import { z as z7 } from "zod";
+var CreateInputSchema = z7.object({
+  name: z7.string().min(1, "Project name is required").max(255, "Project name must be at most 255 characters"),
+  description: z7.string().max(1e3, "Description must be at most 1000 characters").optional()
 });
 function formatDate3(date) {
   const d = typeof date === "string" ? new Date(date) : date;
@@ -1046,9 +1814,16 @@ Returns:
     }
     try {
       const client = getApiClient();
+      const defaultOrg = await client.getDefaultOrganization();
+      if (!defaultOrg) {
+        return createErrorResult(
+          "\u274C No organization found.\n\nPlease create an organization first at:\n  https://planflow.tools/dashboard/team"
+        );
+      }
       const project = await client.createProject({
         name: input.name,
-        description: input.description
+        description: input.description,
+        organizationId: defaultOrg.id
       });
       logger.info("Successfully created project", { projectId: project.id });
       const output = [
@@ -1101,11 +1876,11 @@ Please try again or check your connection.`
 };
 
 // src/tools/sync.ts
-import { z as z7 } from "zod";
-var SyncInputSchema = z7.object({
-  projectId: z7.string().uuid("Invalid project ID format"),
-  direction: z7.enum(["push", "pull"]),
-  content: z7.string().optional()
+import { z as z8 } from "zod";
+var SyncInputSchema = z8.object({
+  projectId: z8.string().uuid("Invalid project ID format"),
+  direction: z8.enum(["push", "pull"]),
+  content: z8.string().optional()
   // Required for push, ignored for pull
 });
 function formatDate4(date) {
@@ -1261,10 +2036,10 @@ async function executePull(client, projectId) {
 }
 
 // src/tools/task-list.ts
-import { z as z8 } from "zod";
-var TaskListInputSchema = z8.object({
-  projectId: z8.string().uuid("Project ID must be a valid UUID"),
-  status: z8.enum(["TODO", "IN_PROGRESS", "DONE", "BLOCKED"]).optional().describe("Filter tasks by status")
+import { z as z9 } from "zod";
+var TaskListInputSchema = z9.object({
+  projectId: z9.string().uuid("Project ID must be a valid UUID"),
+  status: z9.enum(["TODO", "IN_PROGRESS", "DONE", "BLOCKED"]).optional().describe("Filter tasks by status")
 });
 function truncate2(str, maxLength) {
   if (!str) return "-";
@@ -1434,11 +2209,11 @@ Please try again or check your connection.`
 };
 
 // src/tools/task-update.ts
-import { z as z9 } from "zod";
-var TaskUpdateInputSchema = z9.object({
-  projectId: z9.string().uuid("Project ID must be a valid UUID"),
-  taskId: z9.string().describe('Task ID (e.g., "T1.1", "T2.3")'),
-  status: z9.enum(["TODO", "IN_PROGRESS", "DONE", "BLOCKED"]).describe("New status for the task")
+import { z as z10 } from "zod";
+var TaskUpdateInputSchema = z10.object({
+  projectId: z10.string().uuid("Project ID must be a valid UUID"),
+  taskId: z10.string().describe('Task ID (e.g., "T1.1", "T2.3")'),
+  status: z10.enum(["TODO", "IN_PROGRESS", "DONE", "BLOCKED"]).describe("New status for the task")
 });
 function getStatusEmoji2(status) {
   switch (status) {
@@ -1622,9 +2397,9 @@ Please try again or check your connection.`
 };
 
 // src/tools/task-next.ts
-import { z as z10 } from "zod";
-var TaskNextInputSchema = z10.object({
-  projectId: z10.string().uuid("Project ID must be a valid UUID")
+import { z as z11 } from "zod";
+var TaskNextInputSchema = z11.object({
+  projectId: z11.string().uuid("Project ID must be a valid UUID")
 });
 function getComplexityIndicator3(complexity) {
   switch (complexity) {
@@ -2023,13 +2798,13 @@ Please try again or check your connection.`
 };
 
 // src/tools/notifications.ts
-import { z as z11 } from "zod";
-var NotificationsInputSchema = z11.object({
-  action: z11.enum(["list", "read", "read-all"]).default("list").describe("Action to perform: list, read (mark one as read), or read-all"),
-  projectId: z11.string().uuid("Project ID must be a valid UUID").optional().describe("Filter notifications by project (optional)"),
-  notificationId: z11.string().uuid("Notification ID must be a valid UUID").optional().describe('Notification ID to mark as read (required for "read" action)'),
-  unreadOnly: z11.boolean().default(true).describe("Only show unread notifications (default: true)"),
-  limit: z11.number().int().min(1).max(100).default(20).describe("Maximum number of notifications to fetch (default: 20)")
+import { z as z12 } from "zod";
+var NotificationsInputSchema = z12.object({
+  action: z12.enum(["list", "read", "read-all"]).default("list").describe("Action to perform: list, read (mark one as read), or read-all"),
+  projectId: z12.string().uuid("Project ID must be a valid UUID").optional().describe("Filter notifications by project (optional)"),
+  notificationId: z12.string().uuid("Notification ID must be a valid UUID").optional().describe('Notification ID to mark as read (required for "read" action)'),
+  unreadOnly: z12.boolean().default(true).describe("Only show unread notifications (default: true)"),
+  limit: z12.number().int().min(1).max(100).default(20).describe("Maximum number of notifications to fetch (default: 20)")
 });
 function getTypeEmoji(type) {
   switch (type) {
@@ -2230,11 +3005,11 @@ Please try again or check your connection.`
 };
 
 // src/tools/activity.ts
-import { z as z12 } from "zod";
-var ActivityInputSchema = z12.object({
-  projectId: z12.string().uuid("Project ID must be a valid UUID").describe("Project ID to get activity for"),
-  taskId: z12.string().optional().describe('Optional: Filter activity for a specific task (e.g., "T1.1")'),
-  action: z12.enum([
+import { z as z13 } from "zod";
+var ActivityInputSchema = z13.object({
+  projectId: z13.string().uuid("Project ID must be a valid UUID").describe("Project ID to get activity for"),
+  taskId: z13.string().optional().describe('Optional: Filter activity for a specific task (e.g., "T1.1")'),
+  action: z13.enum([
     "task_created",
     "task_updated",
     "task_deleted",
@@ -2251,8 +3026,8 @@ var ActivityInputSchema = z12.object({
     "member_removed",
     "member_role_changed"
   ]).optional().describe("Optional: Filter by action type"),
-  entityType: z12.enum(["task", "comment", "project", "member", "invitation"]).optional().describe("Optional: Filter by entity type"),
-  limit: z12.number().int().min(1).max(100).default(20).describe("Maximum number of activities to fetch (default: 20)")
+  entityType: z13.enum(["task", "comment", "project", "member", "invitation"]).optional().describe("Optional: Filter by entity type"),
+  limit: z13.number().int().min(1).max(100).default(20).describe("Maximum number of activities to fetch (default: 20)")
 });
 function getActionEmoji(action) {
   switch (action) {
@@ -2492,10 +3267,10 @@ Please try again or check your connection.`
 };
 
 // src/tools/comments.ts
-import { z as z13 } from "zod";
-var CommentsInputSchema = z13.object({
-  projectId: z13.string().uuid("Project ID must be a valid UUID").describe("Project ID containing the task"),
-  taskId: z13.string().describe('Task ID to view comments for (e.g., "T1.1")')
+import { z as z14 } from "zod";
+var CommentsInputSchema = z14.object({
+  projectId: z14.string().uuid("Project ID must be a valid UUID").describe("Project ID containing the task"),
+  taskId: z14.string().describe('Task ID to view comments for (e.g., "T1.1")')
 });
 function formatRelativeTime3(dateString) {
   const date = new Date(dateString);
@@ -2642,12 +3417,12 @@ Please try again or check your connection.`
 };
 
 // src/tools/comment.ts
-import { z as z14 } from "zod";
-var CommentInputSchema = z14.object({
-  projectId: z14.string().uuid("Project ID must be a valid UUID").describe("Project ID containing the task"),
-  taskId: z14.string().describe('Task ID to add comment to (e.g., "T1.1")'),
-  content: z14.string().min(1, "Comment content is required").max(1e4, "Comment must be at most 10000 characters").describe("Comment content (supports @mentions like @user@email.com)"),
-  parentId: z14.string().uuid("Parent comment ID must be a valid UUID").optional().describe("Optional: Reply to a specific comment by providing its ID")
+import { z as z15 } from "zod";
+var CommentInputSchema = z15.object({
+  projectId: z15.string().uuid("Project ID must be a valid UUID").describe("Project ID containing the task"),
+  taskId: z15.string().describe('Task ID to add comment to (e.g., "T1.1")'),
+  content: z15.string().min(1, "Comment content is required").max(1e4, "Comment must be at most 10000 characters").describe("Comment content (supports @mentions like @user@email.com)"),
+  parentId: z15.string().uuid("Parent comment ID must be a valid UUID").optional().describe("Optional: Reply to a specific comment by providing its ID")
 });
 function formatAuthorName2(name, email) {
   if (name) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "planflow-mcp",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "PlanFlow MCP Server for Claude Code - AI-native project management from your terminal",
   "author": "PlanFlow <hello@planflow.tools>",
   "license": "MIT",
@@ -53,7 +53,7 @@
   },
   "scripts": {
     "dev": "tsx watch src/index.ts",
-    "build": "tsup src/index.ts --format esm --dts --clean",
+    "build": "tsup",
     "start": "node dist/index.js",
     "lint": "eslint src/",
     "typecheck": "tsc --noEmit",
@@ -64,7 +64,6 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "@planflow/shared": "workspace:*",
     "zod": "^3.23.0"
   },
   "devDependencies": {