@mtaap/mcp 0.1.3 → 0.2.1

package/dist/chunk-7YL3QGGO.js

@@ -1,2268 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-
-// src/index.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
-// ../../packages/db/dist/index.js
-var dist_exports = {};
-__export(dist_exports, {
-  prisma: () => prisma2
-});
-
-// ../../packages/db/dist/client.js
-var client_exports = {};
-__export(client_exports, {
-  default: () => client_default,
-  prisma: () => prisma
-});
-__reExport(client_exports, client_star);
-import { PrismaClient } from "@prisma/client";
-import { PrismaPg } from "@prisma/adapter-pg";
-import * as client_star from "@prisma/client";
-var adapter = new PrismaPg({
-  connectionString: process.env.DATABASE_URL
-});
-var globalForPrisma = globalThis;
-var prisma = globalForPrisma.prisma ?? new PrismaClient({
-  adapter
-});
-if (process.env.NODE_ENV !== "production") {
-  globalForPrisma.prisma = prisma;
-}
-var client_default = prisma;
-
-// ../../packages/core/dist/constants/enums.js
-var TaskState;
-(function(TaskState2) {
-  TaskState2["BACKLOG"] = "BACKLOG";
-  TaskState2["READY"] = "READY";
-  TaskState2["IN_PROGRESS"] = "IN_PROGRESS";
-  TaskState2["REVIEW"] = "REVIEW";
-  TaskState2["DONE"] = "DONE";
-})(TaskState || (TaskState = {}));
-var UserRole;
-(function(UserRole2) {
-  UserRole2["ADMIN"] = "ADMIN";
-  UserRole2["MEMBER"] = "MEMBER";
-})(UserRole || (UserRole = {}));
-var ProjectType;
-(function(ProjectType2) {
-  ProjectType2["TEAM"] = "TEAM";
-  ProjectType2["PERSONAL"] = "PERSONAL";
-})(ProjectType || (ProjectType = {}));
-var ProjectOrigin;
-(function(ProjectOrigin2) {
-  ProjectOrigin2["CREATED"] = "CREATED";
-  ProjectOrigin2["PROMOTED"] = "PROMOTED";
-})(ProjectOrigin || (ProjectOrigin = {}));
-var TaskPriority;
-(function(TaskPriority2) {
-  TaskPriority2["LOW"] = "LOW";
-  TaskPriority2["MEDIUM"] = "MEDIUM";
-  TaskPriority2["HIGH"] = "HIGH";
-  TaskPriority2["CRITICAL"] = "CRITICAL";
-})(TaskPriority || (TaskPriority = {}));
-var DeploymentMode;
-(function(DeploymentMode2) {
-  DeploymentMode2["SAAS"] = "saas";
-  DeploymentMode2["ONPREM"] = "onprem";
-})(DeploymentMode || (DeploymentMode = {}));
-var ErrorType;
-(function(ErrorType3) {
-  ErrorType3["BUILD_FAILURE"] = "BUILD_FAILURE";
-  ErrorType3["TEST_FAILURE"] = "TEST_FAILURE";
-  ErrorType3["CONFLICT"] = "CONFLICT";
-  ErrorType3["AUTH_ERROR"] = "AUTH_ERROR";
-  ErrorType3["OTHER"] = "OTHER";
-})(ErrorType || (ErrorType = {}));
-var PRStatus;
-(function(PRStatus2) {
-  PRStatus2["OPEN"] = "OPEN";
-  PRStatus2["CLOSED"] = "CLOSED";
-  PRStatus2["MERGED"] = "MERGED";
-  PRStatus2["DELETED"] = "DELETED";
-})(PRStatus || (PRStatus = {}));
-var PricingTier;
-(function(PricingTier2) {
-  PricingTier2["FREE"] = "FREE";
-  PricingTier2["PRO"] = "PRO";
-  PricingTier2["ENTERPRISE"] = "ENTERPRISE";
-})(PricingTier || (PricingTier = {}));
-var ApiKeyPermission;
-(function(ApiKeyPermission2) {
-  ApiKeyPermission2["READ"] = "READ";
-  ApiKeyPermission2["WRITE"] = "WRITE";
-  ApiKeyPermission2["ADMIN"] = "ADMIN";
-})(ApiKeyPermission || (ApiKeyPermission = {}));
-var WebSocketEventType;
-(function(WebSocketEventType2) {
-  WebSocketEventType2["TASK_ASSIGNED"] = "task.assigned";
-  WebSocketEventType2["TASK_ABANDONED"] = "task.abandoned";
-  WebSocketEventType2["TASK_PROGRESS"] = "task.progress";
-  WebSocketEventType2["TASK_PR_CREATED"] = "task.pr_created";
-  WebSocketEventType2["TASK_REVIEW_REQUESTED"] = "task.review_requested";
-  WebSocketEventType2["TASK_COMPLETED"] = "task.completed";
-  WebSocketEventType2["TASK_ERROR"] = "task.error";
-  WebSocketEventType2["TASK_STATE_CHANGED"] = "task.state_changed";
-  WebSocketEventType2["MEMBER_JOINED"] = "member.joined";
-})(WebSocketEventType || (WebSocketEventType = {}));
-var AuthProvider;
-(function(AuthProvider2) {
-  AuthProvider2["CREDENTIALS"] = "credentials";
-  AuthProvider2["LDAP"] = "ldap";
-  AuthProvider2["SSO"] = "sso";
-})(AuthProvider || (AuthProvider = {}));
-var SubscriptionStatus;
-(function(SubscriptionStatus2) {
-  SubscriptionStatus2["ACTIVE"] = "ACTIVE";
-  SubscriptionStatus2["INACTIVE"] = "INACTIVE";
-  SubscriptionStatus2["PAST_DUE"] = "PAST_DUE";
-  SubscriptionStatus2["CANCELED"] = "CANCELED";
-  SubscriptionStatus2["INCOMPLETE"] = "INCOMPLETE";
-})(SubscriptionStatus || (SubscriptionStatus = {}));
-var EventType;
-(function(EventType2) {
-  EventType2["AUTH"] = "AUTH";
-  EventType2["AUTHORIZATION"] = "AUTHORIZATION";
-  EventType2["ACCESS"] = "ACCESS";
-  EventType2["MODIFICATION"] = "MODIFICATION";
-})(EventType || (EventType = {}));
-
-// ../../packages/core/dist/constants/state-machine.js
-var VALID_TRANSITIONS = {
-  [TaskState.BACKLOG]: [TaskState.READY],
-  [TaskState.READY]: [TaskState.BACKLOG, TaskState.IN_PROGRESS],
-  [TaskState.IN_PROGRESS]: [
-    TaskState.BACKLOG,
-    TaskState.READY,
-    TaskState.REVIEW
-  ],
-  [TaskState.REVIEW]: [
-    TaskState.BACKLOG,
-    TaskState.READY,
-    TaskState.IN_PROGRESS,
-    TaskState.DONE
-  ],
-  [TaskState.DONE]: []
-};
-
-// ../../packages/core/dist/version.js
-var VERSION = "0.1.0";
-
-// ../../packages/core/dist/config/index.js
-var DEPLOYMENT_MODE = process.env.DEPLOYMENT_MODE || "saas";
-var config = {
-  version: VERSION,
-  deploymentMode: DEPLOYMENT_MODE,
-  billing: {
-    enabled: DEPLOYMENT_MODE === "saas",
-    revenuecat: {
-      publicKey: process.env.REVENUECAT_PUBLIC_API_KEY,
-      stripeKey: process.env.STRIPE_SECRET_KEY
-      // Required by RevenueCat Web Billing
-    }
-  },
-  licensing: {
-    enabled: DEPLOYMENT_MODE === "onprem",
-    licenseKey: process.env.LICENSE_KEY
-  },
-  auth: {
-    credentials: true,
-    ldap: process.env.LDAP_ENABLED === "true"
-  },
-  git: {
-    deleteMergedBranches: process.env.DELETE_MERGED_BRANCHES !== "false",
-    enforceConventionalCommits: process.env.ENFORCE_CONVENTIONAL_COMMITS === "true",
-    defaultBaseBranch: process.env.DEFAULT_BASE_BRANCH || "develop"
-  },
-  pricing: {
-    maxPersonalProjects: {
-      FREE: 2,
-      PRO: 5,
-      ENTERPRISE: 10
-    },
-    maxCollaboratorsPerProject: {
-      FREE: 3,
-      PRO: -1,
-      ENTERPRISE: -1
-    },
-    maxProjectsPerOrg: {
-      FREE: 5,
-      PRO: -1,
-      ENTERPRISE: -1
-    },
-    maxSeats: {
-      FREE: 3,
-      PRO: -1,
-      ENTERPRISE: -1
-    },
-    // Default seats when subscription doesn't specify an explicit seat count
-    defaultSeats: {
-      FREE: 3,
-      PRO: 10,
-      ENTERPRISE: 999999
-    }
-  },
-  features: {
-    stripe: {
-      enabled: DEPLOYMENT_MODE === "saas"
-    },
-    gitlab: {
-      enabled: true
-    },
-    ldap: {
-      enabled: process.env.LDAP_ENABLED === "true"
-    },
-    auditLogs: {
-      enabled: process.env.AUDIT_LOGS_ENABLED === "true"
-    }
-  },
-  api: {
-    apiKey: {
-      defaultExpiryDays: 90,
-      prefix: "usr_"
-    },
-    rateLimit: {
-      requestsPerMinute: 100,
-      requestsPerHour: 1e3
-    }
-  },
-  limits: {
-    projectNameMaxLength: 100,
-    taskDescriptionMaxLength: 5e3,
-    notesMaxLength: 500,
-    conventionsNotesMaxLength: 500,
-    recentCompletedTasksLimit: 10
-  }
-};
-var DEFAULT_SEAT_LIMITS = {
-  [PricingTier.FREE]: config.pricing.defaultSeats.FREE,
-  [PricingTier.PRO]: config.pricing.defaultSeats.PRO,
-  [PricingTier.ENTERPRISE]: config.pricing.defaultSeats.ENTERPRISE
-};
-
-// ../../packages/core/dist/types/index.js
-import { z } from "zod";
-var UserIdSchema = z.string().regex(/^usr_[a-zA-Z0-9]+$/);
-var UserSchema = z.object({
-  id: UserIdSchema,
-  email: z.string().email(),
-  name: z.string().min(1).max(255),
-  role: z.nativeEnum(UserRole),
-  organizationId: z.string().optional(),
-  lastActiveAt: z.coerce.date().optional(),
-  createdAt: z.coerce.date()
-});
-var OrganizationUserSchema = z.object({
-  id: z.number().int(),
-  userId: UserIdSchema,
-  organizationId: z.string(),
-  roleId: z.nativeEnum(UserRole).optional(),
-  user: UserSchema.pick({ id: true, email: true, name: true, role: true }),
-  createdAt: z.coerce.date()
-});
-var OrganizationIdSchema = z.string().regex(/^org_[a-zA-Z0-9]+$/);
-var OrganizationSchema = z.object({
-  id: OrganizationIdSchema,
-  name: z.string().min(1).max(255),
-  slug: z.string().min(1).max(100).regex(/^[a-z0-9-]+$/),
-  logoUrl: z.string().url().nullable(),
-  accentColor: z.string().regex(/^#[0-9A-Fa-f]{6}$/).nullable(),
-  tenantName: z.string().nullable(),
-  pricingTier: z.nativeEnum(PricingTier),
-  createdAt: z.coerce.date()
-});
-var OrganizationSettingsSchema = z.object({
-  organizationId: OrganizationIdSchema,
-  ldapEnabled: z.boolean(),
-  ldapUrl: z.string().url().nullable(),
-  ldapBindDN: z.string().nullable(),
-  ldapSearchBase: z.string().nullable(),
-  deleteMergedBranches: z.boolean(),
-  enforceConventionalCommits: z.boolean(),
-  maxPersonalProjectsPerUser: z.number().int().min(0)
-});
-var TagSchema = z.object({
-  id: z.string(),
-  name: z.string().min(1).max(50),
-  organizationId: OrganizationIdSchema,
-  createdAt: z.coerce.date()
-});
-var ProjectIdSchema = z.string().regex(/^prj_[a-zA-Z0-9]+$/);
-var ProjectSchema = z.object({
-  id: ProjectIdSchema,
-  name: z.string().min(1).max(100),
-  description: z.string().max(500).nullable(),
-  type: z.nativeEnum(ProjectType),
-  origin: z.nativeEnum(ProjectOrigin),
-  organizationId: OrganizationIdSchema,
-  ownerId: UserIdSchema.nullable(),
-  repositoryUrl: z.string().url(),
-  baseBranch: z.string().default("develop"),
-  tags: z.array(z.string()),
-  createdAt: z.coerce.date(),
-  updatedAt: z.coerce.date()
-});
-var EpicIdSchema = z.string().regex(/^epc_[a-zA-Z0-9]+$/);
-var EpicSchema = z.object({
-  id: EpicIdSchema,
-  projectId: ProjectIdSchema,
-  name: z.string().min(1).max(200),
-  description: z.string().nullable(),
-  createdAt: z.coerce.date(),
-  updatedAt: z.coerce.date()
-});
-var TaskIdSchema = z.string().regex(/^tsk_[a-zA-Z0-9]+$/);
-var TaskSchema = z.object({
-  id: TaskIdSchema,
-  projectId: ProjectIdSchema,
-  epicId: EpicIdSchema.nullable(),
-  title: z.string().min(1).max(200),
-  description: z.string().max(5e3),
-  state: z.nativeEnum(TaskState),
-  priority: z.nativeEnum(TaskPriority),
-  assigneeId: UserIdSchema.nullable(),
-  createdBy: UserIdSchema.nullable(),
-  assignedAt: z.coerce.date().nullable(),
-  startedAt: z.coerce.date().nullable(),
-  completedAt: z.coerce.date().nullable(),
-  branchName: z.string().nullable(),
-  pullRequestUrl: z.string().url().nullable(),
-  pullRequestNumber: z.number().int().nullable(),
-  pullRequestStatus: z.nativeEnum(PRStatus).nullable(),
-  errorType: z.nativeEnum(ErrorType).nullable(),
-  errorMessage: z.string().max(1e3).nullable(),
-  createdAt: z.coerce.date(),
-  updatedAt: z.coerce.date()
-});
-var AcceptanceCriterionSchema = z.object({
-  id: z.string(),
-  taskId: TaskIdSchema,
-  description: z.string().min(1).max(500),
-  completed: z.boolean(),
-  completedAt: z.coerce.date().nullable(),
-  order: z.number().int(),
-  createdAt: z.coerce.date()
-});
-var ProgressUpdateSchema = z.object({
-  id: z.string(),
-  taskId: TaskIdSchema,
-  userId: UserIdSchema,
-  message: z.string().max(2e3),
-  checkpoints: z.array(z.string()).optional(),
-  createdAt: z.coerce.date()
-});
-var TaskNoteSchema = z.object({
-  id: z.string(),
-  taskId: TaskIdSchema,
-  userId: UserIdSchema,
-  content: z.string().max(500),
-  createdAt: z.coerce.date()
-});
-var ApiKeyIdSchema = z.string().regex(/^key_[a-zA-Z0-9]+$/);
-var ApiKeySchema = z.object({
-  id: ApiKeyIdSchema,
-  userId: UserIdSchema,
-  name: z.string().min(1).max(100),
-  keyHash: z.string(),
-  permissions: z.nativeEnum(ApiKeyPermission),
-  lastUsedAt: z.coerce.date().nullable(),
-  expiresAt: z.coerce.date().nullable(),
-  revoked: z.boolean(),
-  createdAt: z.coerce.date()
-});
-var SubscriptionIdSchema = z.string();
-var SubscriptionSchema = z.object({
-  id: SubscriptionIdSchema,
-  organizationId: OrganizationIdSchema,
-  pricingTier: z.nativeEnum(PricingTier),
-  seats: z.number().int().min(0),
-  stripeSubscriptionId: z.string().nullable(),
-  stripeCustomerId: z.string().nullable(),
-  status: z.enum(["active", "past_due", "canceled", "incomplete"]),
-  currentPeriodStart: z.coerce.date(),
-  currentPeriodEnd: z.coerce.date(),
-  createdAt: z.coerce.date()
-});
-var ProjectCollaboratorSchema = z.object({
-  id: z.string(),
-  projectId: ProjectIdSchema,
-  userId: UserIdSchema,
-  addedBy: UserIdSchema,
-  createdAt: z.coerce.date()
-});
-
-// ../../packages/core/dist/validation/index.js
-import { z as z2 } from "zod";
-var ListProjectsInputSchema = z2.object({
-  workspaceType: z2.preprocess((val) => typeof val === "string" ? val.toUpperCase() : val, z2.enum(["TEAM", "PERSONAL", "ALL"]).optional())
-});
-var ListTasksInputSchema = z2.object({
-  projectId: z2.string().optional(),
-  state: z2.nativeEnum(TaskState).optional(),
-  assigneeId: z2.string().optional()
-});
-var GetTaskInputSchema = z2.object({
-  taskId: z2.string().regex(/^tsk_[a-zA-Z0-9]+$/)
-});
-var AssignTaskInputSchema = z2.object({
-  projectId: z2.string().regex(/^prj_[a-zA-Z0-9]+$/),
-  taskId: z2.string().regex(/^tsk_[a-zA-Z0-9]+$/),
-  expectedState: z2.nativeEnum(TaskState).default(TaskState.READY)
-});
-var UpdateProgressInputSchema = z2.object({
-  taskId: z2.string().regex(/^tsk_[a-zA-Z0-9]+$/),
-  statusMessage: z2.string().max(1e3).optional(),
-  completedCheckpointIds: z2.array(z2.string()).optional(),
-  currentCheckpointIndex: z2.number().int().optional()
-});
-var CompleteTaskInputSchema = z2.object({
-  projectId: z2.string().regex(/^prj_[a-zA-Z0-9]+$/),
-  taskId: z2.string().regex(/^tsk_[a-zA-Z0-9]+$/),
-  pullRequestTitle: z2.string().min(1).max(300).optional(),
-  pullRequestBody: z2.string().max(1e4).optional()
-});
-var ReportErrorInputSchema = z2.object({
-  taskId: z2.string().regex(/^tsk_[a-zA-Z0-9]+$/),
-  errorType: z2.nativeEnum(ErrorType),
-  errorMessage: z2.string().min(1).max(1e3),
-  context: z2.string().max(2e3).optional()
-});
-var GetProjectContextInputSchema = z2.object({
-  projectId: z2.string().regex(/^prj_[a-zA-Z0-9]+$/)
-});
-var AddNoteInputSchema = z2.object({
-  taskId: z2.string().regex(/^tsk_[a-zA-Z0-9]+$/),
-  content: z2.string().min(1).max(500)
-});
-var AbandonTaskInputSchema = z2.object({
-  projectId: z2.string().regex(/^prj_[a-zA-Z0-9]+$/),
-  taskId: z2.string().regex(/^tsk_[a-zA-Z0-9]+$/),
-  deleteBranch: z2.boolean().optional()
-});
-var CreatePersonalProjectInputSchema = z2.object({
-  name: z2.string().min(1).max(100),
-  description: z2.string().max(500).optional(),
-  repositoryUrl: z2.string().url()
-});
-var CheckActiveTaskInputSchema = z2.object({});
-var CreateOrganizationInputSchema = z2.object({
-  name: z2.string().min(1).max(255),
-  slug: z2.string().min(1).max(100).regex(/^[a-z0-9-]+$/).optional()
-});
-var UpdateOrganizationInputSchema = z2.object({
-  organizationId: z2.string().regex(/^org_[a-zA-Z0-9]+$/),
-  name: z2.string().min(1).max(255).optional(),
-  logoUrl: z2.string().url().nullable().optional(),
-  accentColor: z2.string().regex(/^#[0-9A-Fa-f]{6}$/, "Invalid hex color format. Expected #RRGGBB").nullable().optional(),
-  tenantName: z2.string().max(255).nullable().optional()
-});
-var CreateProjectInputSchema = z2.object({
-  name: z2.string().min(1).max(100),
-  description: z2.string().max(500).optional(),
-  type: z2.nativeEnum(ProjectType),
-  repositoryUrl: z2.string().url(),
-  baseBranch: z2.string().default("develop").optional(),
-  tags: z2.array(z2.string()).default([])
-});
-var UpdateProjectInputSchema = z2.object({
-  projectId: z2.string().min(1).optional(),
-  name: z2.string().min(1).max(100).optional(),
-  description: z2.string().max(500).optional(),
-  repositoryUrl: z2.string().url().optional(),
-  baseBranch: z2.string().optional(),
-  tags: z2.array(z2.string()).optional()
-});
-var CreateEpicInputSchema = z2.object({
-  projectId: z2.string().regex(/^prj_[a-zA-Z0-9]+$/),
-  name: z2.string().min(1).max(200),
-  description: z2.string().max(2e3).optional()
-});
-var CreateTaskInputSchema = z2.object({
-  projectId: z2.string().min(1),
-  epicId: z2.string().min(1).nullable().optional(),
-  title: z2.string().min(1).max(200),
-  description: z2.string().max(5e3),
-  priority: z2.nativeEnum(TaskPriority).default(TaskPriority.MEDIUM),
-  acceptanceCriteria: z2.array(z2.object({
-    description: z2.string().min(1).max(500)
-  })).min(1)
-});
-var UpdateTaskInputSchema = z2.object({
-  taskId: z2.string().min(1),
-  title: z2.string().min(1).max(200).optional(),
-  description: z2.string().max(5e3).optional(),
-  priority: z2.nativeEnum(TaskPriority).optional(),
-  state: z2.nativeEnum(TaskState).optional(),
-  assigneeId: z2.string().nullable().optional(),
-  acceptanceCriteria: z2.array(z2.object({
-    id: z2.string().optional(),
-    description: z2.string().min(1).max(500),
-    completed: z2.boolean().optional()
-  })).optional()
-});
-var AssignTaskWebappInputSchema = z2.object({
-  taskId: z2.string().min(1),
-  userId: z2.string().min(1)
-});
-var CreateTagInputSchema = z2.object({
-  organizationId: z2.string().regex(/^org_[a-zA-Z0-9]+$/),
-  name: z2.string().min(1).max(50).regex(/^[a-zA-Z0-9\s-]+$/)
-});
-var UpdateTagInputSchema = z2.object({
-  name: z2.string().min(1).max(50).regex(/^[a-zA-Z0-9\s-]+$/)
-});
-var UpdateOrganizationSettingsInputSchema = z2.object({
-  organizationId: z2.string().regex(/^org_[a-zA-Z0-9]+$/),
-  ldapEnabled: z2.boolean().optional(),
-  ldapUrl: z2.string().url().nullable().optional(),
-  ldapBindDN: z2.string().nullable().optional(),
-  ldapSearchBase: z2.string().nullable().optional(),
-  deleteMergedBranches: z2.boolean().optional(),
-  enforceConventionalCommits: z2.boolean().optional(),
-  maxPersonalProjectsPerUser: z2.number().int().min(0).optional(),
-  logoUrl: z2.string().url().nullable().optional(),
-  accentColor: z2.string().regex(/^#[0-9A-Fa-f]{6}$/, "Invalid hex color format. Expected #RRGGBB").nullable().optional(),
-  tenantName: z2.string().max(255).nullable().optional()
-});
-var InviteUserInputSchema = z2.object({
-  organizationId: z2.string().regex(/^org_[a-zA-Z0-9]+$/),
-  email: z2.string().email(),
-  role: z2.nativeEnum(UserRole).default(UserRole.MEMBER),
-  tags: z2.array(z2.string()).default([])
-});
-var AssignUserTagsInputSchema = z2.object({
-  userId: z2.string().regex(/^usr_[a-zA-Z0-9]+$/),
-  tags: z2.array(z2.string()).min(0)
-});
-var InviteCollaboratorInputSchema = z2.object({
-  projectId: z2.string().regex(/^prj_[a-zA-Z0-9]+$/),
-  email: z2.string().email()
-});
-var PublishProjectInputSchema = z2.object({
-  projectId: z2.string().regex(/^prj_[a-zA-Z0-9]+$/),
-  transferOwnership: z2.boolean().default(false),
-  tags: z2.array(z2.string()).min(1)
-});
-var GenerateApiKeyInputSchema = z2.object({
-  name: z2.string().min(1).max(100),
-  expiresInDays: z2.number().int().min(1).max(365).default(90),
-  permissions: z2.nativeEnum(ApiKeyPermission).default(ApiKeyPermission.WRITE)
-});
-var RevokeApiKeyInputSchema = z2.object({
-  keyId: z2.string().regex(/^key_[a-zA-Z0-9]+$/)
-});
-var LoginInputSchema = z2.object({
-  email: z2.string().email(),
-  password: z2.string().min(8).max(255)
-});
-var RegisterInputSchema = z2.object({
-  email: z2.string().email(),
-  password: z2.string().min(8).max(255),
-  name: z2.string().min(1).max(255),
-  organizationSlug: z2.string().min(1).max(100).regex(/^[a-z0-9-]+$/).optional()
-});
-
-// ../../packages/core/dist/logging/metrics.js
-var metrics = /* @__PURE__ */ new Map();
-function labelsToKey(labels) {
-  if (!labels || Object.keys(labels).length === 0)
-    return "";
-  return Object.entries(labels).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}="${v}"`).join(",");
-}
-function createCounter(name, help) {
-  const data = {
-    name,
-    type: "counter",
-    help,
-    values: /* @__PURE__ */ new Map()
-  };
-  metrics.set(name, data);
-  return {
-    inc(labels, value = 1) {
-      const key = labelsToKey(labels);
-      const current = data.values.get(key) || 0;
-      data.values.set(key, current + value);
-    }
-  };
-}
-function createGauge(name, help) {
-  const data = {
-    name,
-    type: "gauge",
-    help,
-    values: /* @__PURE__ */ new Map()
-  };
-  metrics.set(name, data);
-  return {
-    set(labels, value) {
-      const key = labelsToKey(labels);
-      data.values.set(key, value);
-    },
-    inc(labels, value = 1) {
-      const key = labelsToKey(labels);
-      const current = data.values.get(key) || 0;
-      data.values.set(key, current + value);
-    },
-    dec(labels, value = 1) {
-      const key = labelsToKey(labels);
-      const current = data.values.get(key) || 0;
-      data.values.set(key, current - value);
-    }
-  };
-}
-function createHistogram(name, help, buckets = [5e-3, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10]) {
-  const data = {
-    name,
-    type: "histogram",
-    help,
-    values: /* @__PURE__ */ new Map(),
-    buckets
-  };
-  metrics.set(name, data);
-  return {
-    observe(labels, value) {
-      const baseKey = labelsToKey(labels);
-      const sumKey = `${baseKey}|sum`;
-      const countKey = `${baseKey}|count`;
-      data.values.set(sumKey, (data.values.get(sumKey) || 0) + value);
-      data.values.set(countKey, (data.values.get(countKey) || 0) + 1);
-      for (const bucket of buckets) {
-        const bucketKey = `${baseKey}|le="${bucket}"`;
-        if (value <= bucket) {
-          data.values.set(bucketKey, (data.values.get(bucketKey) || 0) + 1);
-        }
-      }
-      const infKey = `${baseKey}|le="+Inf"`;
-      data.values.set(infKey, (data.values.get(infKey) || 0) + 1);
-    }
-  };
-}
-var httpRequestsTotal = createCounter("mtaap_http_requests_total", "Total number of HTTP requests");
-var httpRequestDuration = createHistogram("mtaap_http_request_duration_seconds", "HTTP request duration in seconds");
-var activeUsers = createGauge("mtaap_active_users", "Number of active users");
-var tasksTotal = createCounter("mtaap_tasks_total", "Total number of tasks by state");
-var taskStateChanges = createCounter("mtaap_task_state_changes_total", "Total number of task state changes");
-var httpErrorsTotal = createCounter("mtaap_http_errors_total", "Total number of HTTP errors");
-var httpActiveConnections = createGauge("mtaap_http_active_connections", "Number of active HTTP connections");
-var newSignupsTotal = createCounter("mtaap_new_signups_total", "Total number of new user signups");
-var loginSuccessTotal = createCounter("mtaap_login_success_total", "Total number of successful logins");
-var loginFailureTotal = createCounter("mtaap_login_failure_total", "Total number of failed logins");
-var dbConnectionPoolActive = createGauge("mtaap_db_connection_pool_active", "Number of active database connections");
-var dbConnectionPoolIdle = createGauge("mtaap_db_connection_pool_idle", "Number of idle database connections");
-var dbConnectionPoolMax = createGauge("mtaap_db_connection_pool_max", "Maximum number of database connections");
-var dbQueryDuration = createHistogram("mtaap_db_query_duration_seconds", "Database query duration in seconds");
-var dbSlowQueriesTotal = createCounter("mtaap_db_slow_queries_total", "Total number of slow database queries (>1s)");
-var dbErrorsTotal = createCounter("mtaap_db_errors_total", "Total number of database errors");
-var tasksCreatedTotal = createCounter("mtaap_tasks_created_total", "Total number of tasks created");
-var tasksAssignedTotal = createCounter("mtaap_tasks_assigned_total", "Total number of tasks assigned");
-var tasksCompletedTotal = createCounter("mtaap_tasks_completed_total", "Total number of tasks completed");
-var tasksByState = createGauge("mtaap_tasks_by_state", "Number of tasks by state");
-
-// ../../packages/core/dist/logging/performance-monitor.js
-var MAX_SAMPLES = 1e3;
-var ALERT_COOLDOWN_MS = 5 * 60 * 1e3;
-var DEFAULT_THRESHOLDS = {
-  api: {
-    p50: 100,
-    p95: 500,
-    p99: 1e3
-  },
-  db: {
-    p95: 100,
-    p99: 500
-  },
-  webvitals: {
-    FCP: 2e3,
-    LCP: 2500,
-    FID: 100,
-    CLS: 0.1
-  }
-};
-function cloneThresholds() {
-  return Object.fromEntries(Object.entries(DEFAULT_THRESHOLDS).map(([category, metrics2]) => [
-    category,
-    { ...metrics2 }
-  ]));
-}
-function labelsToKey2(labels) {
-  if (!labels || Object.keys(labels).length === 0)
-    return "";
-  return Object.entries(labels).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => `${key}="${value}"`).join(",");
-}
-function percentile(sortedValues, percentileValue) {
-  if (sortedValues.length === 0)
-    return 0;
-  const rank = Math.ceil(percentileValue / 100 * sortedValues.length);
-  const index = Math.min(Math.max(rank - 1, 0), sortedValues.length - 1);
-  return sortedValues[index];
-}
-var CircularBuffer = class {
-  capacity;
-  values = [];
-  index = 0;
-  size = 0;
-  constructor(capacity) {
-    this.capacity = capacity;
-  }
-  add(value) {
-    if (this.size < this.capacity) {
-      this.values.push(value);
-      this.size += 1;
-      this.index = this.size % this.capacity;
-      return;
-    }
-    this.values[this.index] = value;
-    this.index = (this.index + 1) % this.capacity;
-  }
-  getValues() {
-    if (this.size < this.capacity) {
-      return this.values.slice(0, this.size);
-    }
-    return this.values.slice();
-  }
-};
-var PerformanceMonitor = class {
-  samples = /* @__PURE__ */ new Map();
-  thresholds = cloneThresholds();
-  alertCallback;
-  lastAlertTimestamps = /* @__PURE__ */ new Map();
-  recordTiming(category, name, durationMs, labels) {
-    if (!Number.isFinite(durationMs))
-      return;
-    const categoryMap = this.getCategoryMap(category);
-    const nameMap = this.getNameMap(categoryMap, name);
-    const labelKey = labelsToKey2(labels);
-    const buffer = nameMap.get(labelKey) ?? new CircularBuffer(MAX_SAMPLES);
-    buffer.add(durationMs);
-    nameMap.set(labelKey, buffer);
-  }
-  getPercentiles(category, name) {
-    const samples = this.collectSamples(category, name);
-    if (samples.length === 0) {
-      return { p50: 0, p95: 0, p99: 0 };
-    }
-    const sorted = [...samples].sort((a, b) => a - b);
-    return {
-      p50: percentile(sorted, 50),
-      p95: percentile(sorted, 95),
-      p99: percentile(sorted, 99)
-    };
-  }
-  checkThresholds() {
-    const alerts = [];
-    const now = Date.now();
-    const callbackAlerts = [];
-    for (const [category, nameMap] of this.samples) {
-      const thresholds = this.thresholds[category];
-      if (!thresholds)
-        continue;
-      for (const name of nameMap.keys()) {
-        const percentiles = this.getPercentiles(category, name);
-        for (const [metric, threshold] of Object.entries(thresholds)) {
-          const value = this.resolveMetricValue(metric, name, percentiles);
-          if (value === void 0 || value <= threshold)
-            continue;
-          const alert = {
-            category,
-            name,
-            metric,
-            value,
-            threshold
-          };
-          alerts.push(alert);
-          const alertKey = `${category}|${name}|${metric}`;
-          const lastAlertTime = this.lastAlertTimestamps.get(alertKey);
-          if (!lastAlertTime || now - lastAlertTime >= ALERT_COOLDOWN_MS) {
-            this.lastAlertTimestamps.set(alertKey, now);
-            callbackAlerts.push(alert);
-          }
-        }
-      }
-    }
-    if (callbackAlerts.length > 0 && this.alertCallback) {
-      this.alertCallback(callbackAlerts);
-    }
-    return alerts;
-  }
-  setAlertCallback(callback) {
-    this.alertCallback = callback;
-  }
-  setThreshold(category, metric, value) {
-    if (!this.thresholds[category]) {
-      this.thresholds[category] = {};
-    }
-    this.thresholds[category][metric] = value;
-  }
-  collectSamples(category, name) {
-    const categoryMap = this.samples.get(category);
-    if (!categoryMap)
-      return [];
-    const entries = name ? [[name, categoryMap.get(name)]] : Array.from(categoryMap.entries());
-    const samples = [];
-    for (const [, labelMap] of entries) {
-      if (!labelMap)
-        continue;
-      for (const buffer of labelMap.values()) {
-        samples.push(...buffer.getValues());
-      }
-    }
-    return samples;
-  }
-  resolveMetricValue(metric, name, percentiles) {
-    if (metric === "p50")
-      return percentiles.p50;
-    if (metric === "p95")
-      return percentiles.p95;
-    if (metric === "p99")
-      return percentiles.p99;
-    if (metric === name)
-      return percentiles.p95;
-    return void 0;
-  }
-  getCategoryMap(category) {
-    const existing = this.samples.get(category);
-    if (existing)
-      return existing;
-    const created = /* @__PURE__ */ new Map();
-    this.samples.set(category, created);
-    return created;
-  }
-  getNameMap(categoryMap, name) {
-    const existing = categoryMap.get(name);
-    if (existing)
-      return existing;
-    const created = /* @__PURE__ */ new Map();
-    categoryMap.set(name, created);
-    return created;
-  }
-};
-var defaultMonitor = new PerformanceMonitor();
-function recordTiming(category, name, durationMs, labels) {
-  defaultMonitor.recordTiming(category, name, durationMs, labels);
-}
-
-// ../../packages/core/dist/logging/error-tracker.js
-var NoOpErrorTracker = class {
-  captureError(error, context) {
-    console.error("Error captured:", error.message, context);
-  }
-  captureException(error, context) {
-    console.error("Exception captured:", error, context);
-  }
-  captureMessage(message, level, context) {
-    console[level === "warning" ? "warn" : level](`Message captured [${level}]:`, message, context);
-  }
-  setUser(user) {
-    console.log("User set:", user);
-  }
-  clearUser() {
-    console.log("User cleared");
-  }
-};
-var errorTrackerInstance = new NoOpErrorTracker();
-
-// ../../packages/db/dist/index.js
-__reExport(dist_exports, client_star2);
-import * as client_star2 from "@prisma/client";
-var prisma2 = client_default.$extends({
-  query: {
-    async $allOperations({ args, model, operation, query }) {
-      const start = Date.now();
-      try {
-        return await query(args);
-      } finally {
-        const durationMs = Date.now() - start;
-        const modelLabel = model ?? "raw";
-        recordTiming("db", operation, durationMs, { model: modelLabel });
-        dbQueryDuration.observe({ operation }, durationMs / 1e3);
-        if (durationMs > 1e3) {
-          dbSlowQueriesTotal.inc({ operation });
-        }
-      }
-    }
-  }
-});
-
-// ../../packages/auth/dist/api-key.js
-var API_KEY_PERMISSION_RANK = {
-  [ApiKeyPermission.READ]: 1,
-  [ApiKeyPermission.WRITE]: 2,
-  [ApiKeyPermission.ADMIN]: 3
-};
-async function hashApiKey(apiKey) {
-  const crypto = await import("crypto");
-  return crypto.createHash("sha256").update(apiKey).digest("hex");
-}
-async function validateApiKey(apiKey) {
-  const keyHash = await hashApiKey(apiKey);
-  const keyRecord = await prisma2.apiKey.findFirst({
-    where: {
-      keyHash,
-      revoked: false
-    },
-    include: {
-      user: {
-        include: {
-          organizations: {
-            take: 1,
-            include: {
-              organization: true
-            }
-          }
-        }
-      }
-    }
-  });
-  if (!keyRecord || keyRecord.expiresAt && keyRecord.expiresAt < /* @__PURE__ */ new Date()) {
-    return null;
-  }
-  await prisma2.apiKey.update({
-    where: { id: keyRecord.id },
-    data: { lastUsedAt: /* @__PURE__ */ new Date() }
-  });
-  const orgUser = keyRecord.user.organizations?.[0];
-  return {
-    user: keyRecord.user,
-    organization: orgUser?.organization,
-    apiKey: {
-      id: keyRecord.id,
-      name: keyRecord.name,
-      // Cast Prisma enum to @mtaap/core enum (same values, different types)
-      permissions: keyRecord.permissions,
-      expiresAt: keyRecord.expiresAt,
-      lastUsedAt: keyRecord.lastUsedAt
-    }
-  };
-}
-
-// src/version.ts
-var VERSION2 = "0.1.3";
-
-// ../../packages/git/dist/github.js
-import { Octokit } from "octokit";
-var GitHubProvider = class {
-  octokit;
-  constructor(token) {
-    this.octokit = new Octokit({ auth: token });
-  }
-  async createBranch(options) {
-    try {
-      const { data: ref } = await this.octokit.rest.git.getRef({
-        owner: options.owner,
-        repo: options.repo,
-        ref: `heads/${options.sourceBranch}`
-      });
-      await this.octokit.rest.git.createRef({
-        owner: options.owner,
-        repo: options.repo,
-        ref: `refs/heads/${options.newBranch}`,
-        sha: ref.object.sha
-      });
-      return {
-        success: true,
-        branchName: options.newBranch
-      };
-    } catch (error) {
-      return {
-        success: false,
-        branchName: options.newBranch,
-        error: error.message || "Failed to create branch"
-      };
-    }
-  }
-  async createPR(options) {
-    try {
-      const { data: pr } = await this.octokit.rest.pulls.create({
-        owner: options.owner,
-        repo: options.repo,
-        title: options.title,
-        body: options.body,
-        head: options.head,
-        base: options.base
-      });
-      return {
-        success: true,
-        prUrl: pr.html_url,
-        prNumber: pr.number
-      };
-    } catch (error) {
-      return {
-        success: false,
-        prUrl: "",
-        prNumber: 0,
-        error: error.message || "Failed to create pull request"
-      };
-    }
-  }
-  async getBranchInfo(options) {
-    try {
-      const { data: ref } = await this.octokit.rest.git.getRef({
-        owner: options.owner,
-        repo: options.repo,
-        ref: `heads/${options.branch}`
-      });
-      return ref.object.sha;
-    } catch {
-      return null;
-    }
-  }
-  async listBranches(owner, repo) {
-    try {
-      const { data: branches } = await this.octokit.rest.repos.listBranches({
-        owner,
-        repo,
-        per_page: 100
-      });
-      return branches.map((branch) => ({
-        name: branch.name,
-        commitSha: branch.commit.sha,
-        protected: branch.protected
-      }));
-    } catch (error) {
-      console.error("Failed to list branches:", error);
-      return [];
-    }
-  }
-  async setupWebhook(options) {
-    try {
-      const { data: webhook } = await this.octokit.rest.repos.createWebhook({
-        owner: options.owner,
-        repo: options.repo,
-        name: "web",
-        config: {
-          url: options.url,
-          content_type: "json",
-          secret: options.secret
-        },
-        events: options.events || ["push", "pull_request"],
-        active: true
-      });
-      return {
-        success: true,
-        webhookId: webhook.id
-      };
-    } catch (error) {
-      return {
-        success: false,
-        webhookId: 0,
-        error: error.message || "Failed to setup webhook"
-      };
-    }
-  }
-  async getPRInfo(prNumber, owner, repo) {
-    try {
-      const { data: pr } = await this.octokit.rest.pulls.get({
-        owner,
-        repo,
-        pull_number: prNumber
-      });
-      return {
-        number: pr.number,
-        title: pr.title,
-        state: pr.state,
-        htmlUrl: pr.html_url,
-        mergedAt: pr.merged_at ? new Date(pr.merged_at) : void 0,
-        user: pr.user ? {
-          login: pr.user.login
-        } : void 0
-      };
-    } catch {
-      return null;
-    }
-  }
-  async getRecentCommits(owner, repo, branch, limit = 10) {
-    try {
-      const { data: commits } = await this.octokit.rest.repos.listCommits({
-        owner,
-        repo,
-        sha: branch,
-        per_page: limit
-      });
-      return commits.map((commit) => ({
-        sha: commit.sha,
-        message: commit.commit.message,
-        author: commit.commit.author?.name && commit.commit.author?.email ? {
-          name: commit.commit.author.name,
-          email: commit.commit.author.email
-        } : void 0,
-        date: new Date(commit.commit.author?.date || Date.now())
-      }));
-    } catch {
-      return [];
-    }
-  }
-  async deleteBranch(owner, repo, branch) {
-    try {
-      await this.octokit.rest.git.deleteRef({
-        owner,
-        repo,
-        ref: `heads/${branch}`
-      });
-      return true;
-    } catch (error) {
-      console.error(`Failed to delete branch ${branch}:`, error.message);
-      return false;
-    }
-  }
-  async getRepositoryReadme(owner, repo) {
-    try {
-      const { data } = await this.octokit.rest.repos.getReadme({
-        owner,
-        repo,
-        mediaType: {
-          format: "raw"
-        }
-      });
-      return data;
-    } catch {
-      return null;
-    }
-  }
-  async getRepositoryPackageJson(owner, repo) {
-    try {
-      const { data } = await this.octokit.rest.repos.getContent({
-        owner,
-        repo,
-        path: "package.json"
-      });
-      if ("content" in data && data.type === "file") {
-        return Buffer.from(data.content, "base64").toString("utf-8");
-      }
-      return null;
-    } catch {
-      return null;
-    }
-  }
-  static parseRepositoryUrl(url) {
-    try {
-      const match = url.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
-      if (!match || match.length < 3) {
-        return null;
-      }
-      return {
-        owner: match[1],
-        repo: match[2].replace(/\.git$/, "")
-      };
-    } catch {
-      return null;
-    }
-  }
-  static async verifyWebhookSignature(payload, signature, secret) {
-    const crypto = await import("crypto");
-    const expectedSignature = crypto.createHmac("sha256", secret).update(payload).digest("hex");
-    const parts = signature.split("=");
-    if (parts.length < 2) {
-      return false;
-    }
-    const receivedSignature = parts[1];
-    return crypto.timingSafeEqual(Buffer.from(receivedSignature), Buffer.from(expectedSignature));
-  }
-  async verifyRepositoryAccess(owner, repo) {
-    try {
-      await this.octokit.rest.repos.get({
-        owner,
-        repo
-      });
-      return { success: true };
-    } catch (error) {
-      if (error.status === 404) {
-        return {
-          success: false,
-          error: "Repository not found or you don't have access"
-        };
-      }
-      if (error.status === 401 || error.status === 403) {
-        return {
-          success: false,
-          error: "Authentication failed. Check your GitHub token permissions"
-        };
-      }
-      return {
-        success: false,
-        error: error.message || "Failed to verify repository access"
-      };
-    }
-  }
-};
-
-// ../../packages/git/dist/errors.js
-var GitErrorType;
-(function(GitErrorType2) {
-  GitErrorType2["BRANCH_NOT_FOUND"] = "BRANCH_NOT_FOUND";
-  GitErrorType2["BRANCH_EXISTS"] = "BRANCH_EXISTS";
-  GitErrorType2["AUTH_INVALID"] = "AUTH_INVALID";
-  GitErrorType2["REPOSITORY_NOT_FOUND"] = "REPOSITORY_NOT_FOUND";
-  GitErrorType2["RATE_LIMITED"] = "RATE_LIMITED";
-  GitErrorType2["NETWORK_ERROR"] = "NETWORK_ERROR";
-  GitErrorType2["PERMISSION_DENIED"] = "PERMISSION_DENIED";
-  GitErrorType2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
-})(GitErrorType || (GitErrorType = {}));
-
-// src/permissions.ts
-var PERMISSION_RANK = {
-  READ: 1,
-  WRITE: 2,
-  ADMIN: 3
-};
-function assertApiKeyPermission(apiKey, required, toolName) {
-  const actualRank = PERMISSION_RANK[apiKey.permissions] ?? 0;
-  const requiredRank = PERMISSION_RANK[required] ?? 0;
-  if (actualRank >= requiredRank) {
-    return;
-  }
-  console.warn("API key permission violation", {
-    keyId: apiKey.id,
-    requiredPermission: required,
-    actualPermission: apiKey.permissions,
-    tool: toolName
-  });
-  const error = new Error(
-    `API key lacks required permissions (required: ${required})`
-  );
-  error.status = 403;
-  throw error;
-}
-
-// src/index.ts
-async function getAuthenticatedUser(apiKey) {
-  const result = await validateApiKey(apiKey);
-  if (!result) {
-    throw new Error("Invalid API key");
-  }
-  return {
-    userId: result.user.id,
-    organizationId: result.organization?.id,
-    apiKey: result.apiKey
-  };
-}
-async function ensureAccessControl(projectId, userId, organizationId) {
-  if (!organizationId) {
-    const project = await prisma2.project.findUnique({
-      where: { id: projectId },
-      include: { owner: true }
-    });
-    if (project?.ownerId !== userId) {
-      throw new Error(
-        "Access denied: You do not have permission to access this project"
-      );
-    }
-  } else {
-    const project = await prisma2.project.findUnique({
-      where: { id: projectId },
-      include: { organization: true }
-    });
-    if (!project || project.organizationId !== organizationId) {
-      throw new Error(
-        "Access denied: You do not have permission to access this project"
-      );
-    }
-    const userTags = await prisma2.userTag.findMany({
-      where: { userId },
-      include: { tag: true }
-    });
-    const projectTags = await prisma2.projectTag.findMany({
-      where: { projectId },
-      include: { tag: true }
-    });
-    const userTagNames = new Set(
-      userTags.map((ut) => ut.tag.name)
-    );
-    const projectTagNames = new Set(
-      projectTags.map((pt) => pt.tag.name)
-    );
-    const hasAccess = [...userTagNames].some((tag) => projectTagNames.has(tag));
-    if (!hasAccess) {
-      throw new Error(
-        "Access denied: Your tags do not grant access to this project"
-      );
-    }
-  }
-}
-function getGitHubClient(_organizationId) {
-  const githubToken = process.env.GITHUB_TOKEN;
-  if (!githubToken) {
-    throw new Error("GitHub token not configured");
-  }
-  return new GitHubProvider(githubToken);
-}
-function slugify(text, maxLength = 50) {
-  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").substring(0, maxLength);
-}
-async function createMCPServer() {
-  const server = new McpServer({
-    name: "mtaap",
-    version: VERSION2
-  });
-  const apiKey = process.env.MTAAP_API_KEY;
-  if (!apiKey) {
-    throw new Error("MTAAP_API_KEY environment variable is required");
-  }
-  const auth = await getAuthenticatedUser(apiKey);
-  server.registerTool(
-    "list_projects",
-    {
-      description: "List accessible projects (personal + team via tags)"
-    },
-    async (args) => {
-      assertApiKeyPermission(
-        auth.apiKey,
-        ApiKeyPermission.READ,
-        "list_projects"
-      );
-      const validated = ListProjectsInputSchema.parse(args);
-      const projects = await listProjects(
-        auth.userId,
-        auth.organizationId,
-        validated.workspaceType
-      );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(projects, null, 2)
-          }
-        ]
-      };
-    }
-  );
-  server.registerTool(
-    "list_tasks",
-    {
-      description: "Returns available tasks (filterable by project, state)"
-    },
-    async (args) => {
-      assertApiKeyPermission(auth.apiKey, ApiKeyPermission.READ, "list_tasks");
-      const validated = ListTasksInputSchema.parse(args);
-      if (validated.projectId) {
-        await ensureAccessControl(
-          validated.projectId,
-          auth.userId,
-          auth.organizationId
-        );
-      }
-      const tasks = await listTasks(
-        auth.userId,
-        auth.organizationId,
-        validated.projectId,
-        validated.state,
-        validated.assigneeId
-      );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(tasks, null, 2)
-          }
-        ]
-      };
-    }
-  );
-  server.registerTool(
-    "get_task",
-    {
-      description: "Full task details including acceptance criteria"
-    },
-    async (args) => {
-      assertApiKeyPermission(auth.apiKey, ApiKeyPermission.READ, "get_task");
-      const validated = GetTaskInputSchema.parse(args);
-      const task = await getTaskWithChecks(
-        validated.taskId,
-        auth.userId,
-        auth.organizationId
-      );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(task, null, 2)
-          }
-        ]
-      };
-    }
-  );
-  server.registerTool(
-    "assign_task",
-    {
-      description: "Atomic claim \u2192 creates branch. Fails if already taken."
-    },
-    async (args) => {
-      assertApiKeyPermission(
-        auth.apiKey,
-        ApiKeyPermission.WRITE,
-        "assign_task"
-      );
-      const validated = AssignTaskInputSchema.parse(args);
-      const result = await assignTask(
-        validated.projectId,
-        validated.taskId,
-        auth.userId,
-        auth.organizationId,
-        validated.expectedState
-      );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
-    }
-  );
-  server.registerTool(
-    "update_progress",
-    {
-      description: "Reports status, updates checkboxes, writes checkpoint"
-    },
-    async (args) => {
-      assertApiKeyPermission(
-        auth.apiKey,
-        ApiKeyPermission.WRITE,
-        "update_progress"
-      );
-      const validated = UpdateProgressInputSchema.parse(args);
-      const result = await updateProgress(
-        validated.taskId,
-        auth.userId,
-        validated.statusMessage,
-        validated.completedCheckpointIds,
-        validated.currentCheckpointIndex
-      );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
-    }
-  );
-  server.registerTool(
-    "complete_task",
-    {
-      description: "Marks complete, triggers PR, deletes local state file"
-    },
-    async (args) => {
-      assertApiKeyPermission(
-        auth.apiKey,
-        ApiKeyPermission.WRITE,
-        "complete_task"
-      );
-      const validated = CompleteTaskInputSchema.parse(args);
-      const result = await completeTask(
-        validated.projectId,
-        validated.taskId,
-        auth.userId,
-        auth.organizationId,
-        validated.pullRequestTitle,
-        validated.pullRequestBody
-      );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
-    }
-  );
-  server.registerTool(
-    "check_active_task",
-    {
-      description: "Check for resumable task in .mtaap/active-task.json"
-    },
-    async () => {
-      assertApiKeyPermission(
-        auth.apiKey,
-        ApiKeyPermission.READ,
-        "check_active_task"
-      );
-      const result = await checkActiveTask();
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
-    }
-  );
-  server.registerTool(
-    "report_error",
-    {
-      description: "Report unrecoverable error, displays on task in webapp"
-    },
-    async (args) => {
-      assertApiKeyPermission(
-        auth.apiKey,
-        ApiKeyPermission.WRITE,
-        "report_error"
-      );
-      const validated = ReportErrorInputSchema.parse(args);
-      const result = await reportTaskError(
-        validated.taskId,
-        auth.userId,
-        validated.errorType,
-        validated.errorMessage,
-        validated.context
-      );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
-    }
-  );
-  server.registerTool(
-    "get_project_context",
-    {
-      description: "Returns assembled context (README, stack, conventions)"
-    },
-    async (args) => {
-      assertApiKeyPermission(
-        auth.apiKey,
-        ApiKeyPermission.READ,
-        "get_project_context"
-      );
-      const validated = GetProjectContextInputSchema.parse(args);
-      await ensureAccessControl(
-        validated.projectId,
-        auth.userId,
-        auth.organizationId
-      );
-      const context = await getProjectContext(validated.projectId);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(context, null, 2)
-          }
-        ]
-      };
-    }
-  );
-  server.registerTool(
-    "add_note",
-    {
-      description: "Append implementation notes to task"
-    },
-    async (args) => {
-      assertApiKeyPermission(auth.apiKey, ApiKeyPermission.WRITE, "add_note");
-      const validated = AddNoteInputSchema.parse(args);
-      const result = await addTaskNote(
-        validated.taskId,
-        auth.userId,
-        validated.content
-      );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
-    }
-  );
-  server.registerTool(
-    "abandon_task",
-    {
-      description: "Unassign from a task and optionally delete the branch"
-    },
-    async (args) => {
-      assertApiKeyPermission(
-        auth.apiKey,
-        ApiKeyPermission.WRITE,
-        "abandon_task"
-      );
-      const validated = AbandonTaskInputSchema.parse(args);
-      await ensureAccessControl(
-        validated.projectId,
-        auth.userId,
-        auth.organizationId || null
-      );
-      const result = await abandonTask(
-        validated.taskId,
-        validated.projectId,
-        auth.userId,
-        validated.deleteBranch
-      );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
-    }
-  );
-  server.registerTool(
-    "create_personal_project",
-    {
-      description: "Create project in user's personal workspace"
-    },
-    async (args) => {
-      assertApiKeyPermission(
-        auth.apiKey,
-        ApiKeyPermission.WRITE,
-        "create_personal_project"
-      );
-      const validated = CreatePersonalProjectInputSchema.parse(args);
-      const result = await createPersonalProject(
-        auth.userId,
-        validated.name,
-        validated.description,
-        validated.repositoryUrl
-      );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
-    }
-  );
-  server.registerTool(
-    "get_version",
-    {
-      description: "Get the current MTAAP version"
-    },
-    async () => {
-      assertApiKeyPermission(auth.apiKey, ApiKeyPermission.READ, "get_version");
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(
-              {
-                version: VERSION2,
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              },
-              null,
-              2
-            )
-          }
-        ]
-      };
-    }
-  );
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}
-async function listProjects(userId, organizationId, workspaceType = "ALL") {
-  const where = {};
-  const include = {};
-  if (workspaceType === "PERSONAL" || workspaceType === "ALL") {
-    where.ownerId = userId;
-    include.owner = true;
-  }
-  if (organizationId && (workspaceType === "TEAM" || workspaceType === "ALL")) {
-    where.OR = [
-      { organizationId },
-      { type: ProjectType.PERSONAL, ownerId: userId }
-    ];
-    include.organization = true;
-    include.projectTags = {
-      include: { tag: true }
-    };
-  }
-  const projects = await prisma2.project.findMany({
-    where,
-    include,
-    orderBy: { updatedAt: "desc" }
-  });
-  const formattedProjects = projects.map(
-    (project) => ({
-      id: project.id,
-      name: project.name,
-      description: project.description,
-      type: project.type,
-      origin: project.origin,
-      repositoryUrl: project.repositoryUrl,
-      baseBranch: project.baseBranch,
-      tags: project.projectTags?.map((pt) => pt.tag.name) || [],
-      createdAt: project.createdAt,
-      updatedAt: project.updatedAt
-    })
-  );
-  return formattedProjects;
-}
-async function listTasks(userId, organizationId, projectId, state, assigneeId) {
-  const where = { projectId };
-  if (organizationId) {
-    where.project = {
-      organizationId
-    };
-  }
-  if (state) {
-    where.state = state;
-  }
-  if (assigneeId) {
-    where.assigneeId = assigneeId;
-  }
-  const tasks = await prisma2.task.findMany({
-    where,
-    include: {
-      project: true,
-      assignee: true,
-      creator: true,
-      epic: true
-    },
-    orderBy: { createdAt: "desc" }
-  });
-  const formattedTasks = await Promise.all(
-    tasks.map(async (task) => {
-      const acceptanceCriteria = await prisma2.acceptanceCriterion.findMany({
-        where: { taskId: task.id },
-        orderBy: { order: "asc" }
-      });
-      return {
-        id: task.id,
-        projectId: task.projectId,
-        projectName: task.project?.name || "Unknown",
-        epicId: task.epicId,
-        epicName: task.epic?.name || null,
-        title: task.title,
-        description: task.description,
-        state: task.state,
-        priority: task.priority,
-        assigneeId: task.assigneeId,
-        assigneeName: task.assignee?.name || null,
-        assigneeEmail: task.assignee?.email || null,
-        createdBy: task.createdBy,
-        createdByName: task.creator?.name || null,
-        assignedAt: task.assignedAt,
-        startedAt: task.startedAt,
-        completedAt: task.completedAt,
-        branchName: task.branchName,
-        pullRequestUrl: task.pullRequestUrl,
-        pullRequestNumber: task.pullRequestNumber,
-        errorType: task.errorType,
-        errorMessage: task.errorMessage,
-        acceptanceCriteria: acceptanceCriteria.map((ac) => ({
-          id: ac.id,
-          description: ac.description,
-          completed: ac.completed,
-          completedAt: ac.completedAt,
-          order: ac.order
-        })),
-        createdAt: task.createdAt,
-        updatedAt: task.updatedAt
-      };
-    })
-  );
-  return formattedTasks;
-}
-async function getTaskWithChecks(taskId, userId, organizationId) {
-  const task = await prisma2.task.findUnique({
-    where: { id: taskId },
-    include: {
-      project: {
-        include: {
-          organization: true,
-          projectTags: {
-            include: { tag: true }
-          }
-        }
-      },
-      epic: true,
-      assignee: true,
-      creator: true,
-      acceptanceCriteria: {
-        orderBy: { order: "asc" }
-      },
-      progressUpdates: {
-        orderBy: { createdAt: "desc" },
-        take: 10
-      },
-      notes: {
-        orderBy: { createdAt: "desc" },
-        take: 10
-      }
-    }
-  });
-  if (!task) {
-    throw new Error("Task not found");
-  }
-  if (organizationId && task.project?.organizationId !== organizationId) {
-    const userTags = await prisma2.userTag.findMany({
-      where: { userId },
-      include: { tag: true }
-    });
-    const projectTagNames = new Set(
-      task.project.projectTags?.map(
-        (pt) => pt.tag.name
-      ) || []
-    );
-    const userTagNames = new Set(
-      userTags.map((ut) => ut.tag.name)
-    );
-    const hasAccess = [...userTagNames].some((tag) => projectTagNames.has(tag));
-    if (!hasAccess) {
-      throw new Error(
-        "Access denied: Your tags do not grant access to this project"
-      );
-    }
-  }
-  const formattedTask = {
-    id: task.id,
-    projectId: task.projectId,
-    projectName: task.project?.name || "Unknown",
-    epicId: task.epicId,
-    epicName: task.epic?.name || null,
-    title: task.title,
-    description: task.description,
-    state: task.state,
-    priority: task.priority,
-    assigneeId: task.assigneeId,
-    assigneeName: task.assignee?.name || null,
-    assigneeEmail: task.assignee?.email || null,
-    createdBy: task.createdBy,
-    createdByName: task.creator?.name || null,
-    assignedAt: task.assignedAt,
-    startedAt: task.startedAt,
-    completedAt: task.completedAt,
-    branchName: task.branchName,
-    pullRequestUrl: task.pullRequestUrl,
-    pullRequestNumber: task.pullRequestNumber,
-    errorType: task.errorType,
-    errorMessage: task.errorMessage,
-    acceptanceCriteria: task.acceptanceCriteria.map(
-      (ac) => ({
-        id: ac.id,
-        description: ac.description,
-        completed: ac.completed,
-        completedAt: ac.completedAt,
-        order: ac.order
-      })
-    ),
-    progressUpdates: task.progressUpdates.map(
-      (pu) => ({
-        id: pu.id,
-        message: pu.message,
-        checkpoints: pu.checkpoints,
-        userId: pu.userId,
-        createdAt: pu.createdAt
-      })
-    ),
-    notes: task.notes.map((note) => ({
-      id: note.id,
-      content: note.content,
-      userId: note.userId,
-      createdAt: note.createdAt
-    })),
-    createdAt: task.createdAt,
-    updatedAt: task.updatedAt
-  };
-  return formattedTask;
-}
-async function assignTask(projectId, taskId, userId, organizationId, expectedState = TaskState.READY) {
-  await ensureAccessControl(projectId, userId, organizationId);
-  const task = await prisma2.task.findUnique({
-    where: { id: taskId },
-    include: { project: true }
-  });
-  if (!task) {
-    throw new Error("Task not found");
-  }
-  if (task.state !== expectedState) {
-    return {
-      success: false,
-      taskId,
-      currentState: task.state,
-      message: `Task is already in state: ${task.state}`
-    };
-  }
-  const repoInfo = GitHubProvider.parseRepositoryUrl(
-    task.project?.repositoryUrl || ""
-  );
-  if (!repoInfo) {
-    throw new Error("Invalid repository URL");
-  }
-  const github = getGitHubClient(task.project?.organizationId || "");
-  const branchSuffix = slugify(task.title);
-  const branchName = `feature/${taskId}-${branchSuffix}`;
-  const createResult = await github.createBranch({
-    owner: repoInfo.owner,
-    repo: repoInfo.repo,
-    sourceBranch: task.project?.baseBranch || "develop",
-    newBranch: branchName
-  });
-  if (!createResult.success) {
-    throw new Error(`Failed to create branch: ${createResult.error}`);
-  }
-  const updatedTask = await prisma2.task.update({
-    where: { id: taskId },
-    data: {
-      state: TaskState.IN_PROGRESS,
-      assigneeId: userId,
-      assignedAt: /* @__PURE__ */ new Date(),
-      branchName,
-      startedAt: /* @__PURE__ */ new Date()
-    }
-  });
-  return {
-    success: true,
-    taskId: updatedTask.id,
-    branchName
-  };
-}
-async function updateProgress(taskId, userId, statusMessage, completedCheckpointIds, _currentCheckpointIndex) {
-  const task = await prisma2.task.findUnique({
-    where: { id: taskId }
-  });
-  if (!task) {
-    throw new Error("Task not found");
-  }
-  if (task.assigneeId !== userId) {
-    throw new Error("You are not assigned to this task");
-  }
-  if (completedCheckpointIds && completedCheckpointIds.length > 0) {
-    await prisma2.acceptanceCriterion.updateMany({
-      where: {
-        id: { in: completedCheckpointIds }
-      },
-      data: {
-        completed: true,
-        completedAt: /* @__PURE__ */ new Date()
-      }
-    });
-  }
-  if (statusMessage) {
-    await prisma2.progressUpdate.create({
-      data: {
-        taskId,
-        userId,
-        message: statusMessage,
-        checkpoints: []
-      }
-    });
-  }
-  const updatedTask = await prisma2.task.update({
-    where: { id: taskId },
-    data: {
-      updatedAt: /* @__PURE__ */ new Date()
-    }
-  });
-  return {
-    success: true,
-    taskId: updatedTask.id
-  };
-}
-async function completeTask(projectId, taskId, userId, organizationId, pullRequestTitle, pullRequestBody) {
-  await ensureAccessControl(projectId, userId, organizationId);
-  const task = await prisma2.task.findUnique({
-    where: { id: taskId },
-    include: { project: true }
-  });
-  if (!task) {
-    throw new Error("Task not found");
-  }
-  if (task.assigneeId !== userId) {
-    throw new Error("You are not assigned to this task");
-  }
-  if (task.state !== TaskState.IN_PROGRESS) {
-    throw new Error("Task must be in progress to be completed");
-  }
-  if (!task.branchName) {
-    throw new Error("Task has no associated branch");
-  }
-  const repoInfo = GitHubProvider.parseRepositoryUrl(
-    task.project?.repositoryUrl || ""
-  );
-  if (!repoInfo) {
-    throw new Error("Invalid repository URL");
-  }
-  const github = getGitHubClient(task.project?.organizationId || "");
-  const acceptanceCriteria = await prisma2.acceptanceCriterion.findMany({
-    where: { taskId },
-    orderBy: { order: "asc" }
-  });
-  const acceptanceChecklist = acceptanceCriteria.map(
-    (ac) => `- [${ac.completed ? "x" : " "}] ${ac.description}`
-  ).join("\n");
-  const prTitle = pullRequestTitle || `[${taskId}] ${task.title}`;
-  const prBody = pullRequestBody || `${task.description}
-
-### Acceptance Criteria
-
-${acceptanceChecklist}`;
-  const createResult = await github.createPR({
-    owner: repoInfo.owner,
-    repo: repoInfo.repo,
-    title: prTitle,
-    body: prBody,
-    head: task.branchName,
-    base: task.project?.baseBranch || "develop"
-  });
-  if (!createResult.success) {
-    throw new Error(`Failed to create PR: ${createResult.error}`);
-  }
-  const updatedTask = await prisma2.task.update({
-    where: { id: taskId },
-    data: {
-      state: TaskState.REVIEW,
-      completedAt: /* @__PURE__ */ new Date(),
-      pullRequestUrl: createResult.prUrl,
-      pullRequestNumber: createResult.prNumber
-    }
-  });
-  return {
-    success: true,
-    taskId: updatedTask.id,
-    prUrl: createResult.prUrl,
-    prNumber: createResult.prNumber
-  };
-}
-async function checkActiveTask() {
-  const fs = await import("fs");
-  const path = await import("path");
-  const activeTaskPath = path.join(process.cwd(), ".mtaap", "active-task.json");
-  if (!await fs.promises.access(activeTaskPath).catch(() => false)) {
-    return {
-      hasActiveTask: false,
-      task: null
-    };
-  }
-  const content = await fs.promises.readFile(activeTaskPath, "utf-8");
-  const activeTask = JSON.parse(content);
-  return {
-    hasActiveTask: true,
-    task: activeTask
-  };
-}
-async function reportTaskError(taskId, userId, errorType, errorMessage, _context) {
-  const task = await prisma2.task.findUnique({
-    where: { id: taskId }
-  });
-  if (!task) {
-    throw new Error("Task not found");
-  }
-  if (task.assigneeId !== userId) {
-    throw new Error("You are not assigned to this task");
-  }
-  const updatedTask = await prisma2.task.update({
-    where: { id: taskId },
-    data: {
-      errorType,
-      errorMessage
-    }
-  });
-  return {
-    success: true,
-    taskId: updatedTask.id
-  };
-}
-async function getProjectContext(projectId) {
-  const project = await prisma2.project.findUnique({
-    where: { id: projectId },
-    include: {
-      organization: {
-        include: { settings: true }
-      }
-    }
-  });
-  if (!project) {
-    throw new Error("Project not found");
-  }
-  const repoInfo = GitHubProvider.parseRepositoryUrl(project.repositoryUrl);
-  let readme = "";
-  let stack = [];
-  if (repoInfo) {
-    const github = getGitHubClient(project.organizationId || "");
-    const readmeResult = await github.getRepositoryReadme(
-      repoInfo.owner,
-      repoInfo.repo
-    );
-    readme = readmeResult || "No README found";
-    const packageJsonResult = await github.getRepositoryPackageJson(
-      repoInfo.owner,
-      repoInfo.repo
-    );
-    if (packageJsonResult) {
-      const packageJson = JSON.parse(packageJsonResult);
-      const deps = {
-        ...packageJson.dependencies,
-        ...packageJson.devDependencies
-      };
-      stack = Object.keys(deps).slice(0, 20);
-    }
-  }
-  const recentCompletedTasks = await prisma2.task.findMany({
-    where: {
-      project: {
-        id: projectId
-      },
-      state: TaskState.DONE
-    },
-    orderBy: { completedAt: "desc" },
-    take: 10,
-    include: {
-      creator: {
-        select: { id: true, name: true }
-      }
-    }
-  });
-  const conventions = {
-    branchPrefix: "feature/",
-    commitFormat: project.organization?.settings?.enforceConventionalCommits ? "conventional" : "none",
-    testCommand: "npm test",
-    baseBranch: project.baseBranch || "develop",
-    notes: project.organization?.settings?.maxPersonalProjectsPerUser?.toString() || ""
-  };
-  return {
-    readme: readme.substring(0, 2e3),
-    stack,
-    recentCompleted: recentCompletedTasks.map(
-      (task) => ({
-        id: task.id,
-        title: task.title,
-        completedAt: task.completedAt
-      })
-    ),
-    conventions
-  };
-}
-async function addTaskNote(taskId, userId, content) {
-  const task = await prisma2.task.findUnique({
-    where: { id: taskId }
-  });
-  if (!task) {
-    throw new Error("Task not found");
-  }
-  if (task.assigneeId !== userId) {
-    throw new Error("You are not assigned to this task");
-  }
-  const note = await prisma2.taskNote.create({
-    data: {
-      taskId,
-      userId,
-      content
-    }
-  });
-  return {
-    success: true,
-    noteId: note.id
-  };
-}
-async function abandonTask(taskId, projectId, userId, deleteBranch) {
-  const task = await prisma2.task.findUnique({
-    where: { id: taskId },
-    include: { project: true }
-  });
-  if (!task) {
-    throw new Error("Task not found");
-  }
-  if (task.projectId !== projectId) {
-    throw new Error("Task does not belong to the specified project");
-  }
-  if (task.assigneeId !== userId) {
-    throw new Error("You can only abandon tasks you are assigned to");
-  }
-  const repositoryUrl = task.project?.repositoryUrl;
-  const repoInfo = repositoryUrl ? GitHubProvider.parseRepositoryUrl(repositoryUrl) : void 0;
-  if (deleteBranch && repoInfo && task.branchName) {
-    const github = getGitHubClient(task.project?.organizationId || "");
-    try {
-      await github.deleteBranch(repoInfo.owner, repoInfo.repo, task.branchName);
-    } catch (error) {
-      console.error("Failed to delete GitHub branch when abandoning task", {
-        taskId,
-        projectId: task.projectId,
-        organizationId: task.project?.organizationId,
-        repositoryOwner: repoInfo.owner,
-        repositoryName: repoInfo.repo,
-        branchName: task.branchName,
-        error
-      });
-      throw new Error("Failed to delete branch");
-    }
-  }
-  const newState = task.state === TaskState.IN_PROGRESS ? TaskState.READY : task.state;
-  const updatedTask = await prisma2.task.update({
-    where: { id: taskId },
-    data: {
-      state: newState,
-      assigneeId: null,
-      assignedAt: null,
-      startedAt: null,
-      updatedAt: /* @__PURE__ */ new Date()
-    }
-  });
-  return {
-    success: true,
-    taskId: updatedTask.id,
-    state: updatedTask.state,
-    branchDeleted: deleteBranch ? !!repoInfo && !!task.branchName : false
-  };
-}
-async function createPersonalProject(userId, name, description, repositoryUrl) {
-  const user = await prisma2.user.findUnique({
-    where: { id: userId },
-    include: { organizations: true }
-  });
-  if (!user) {
-    throw new Error("User not found");
-  }
-  const repoInfo = GitHubProvider.parseRepositoryUrl(repositoryUrl);
-  if (!repoInfo) {
-    throw new Error("Invalid repository URL");
-  }
-  const github = getGitHubClient(user.organizations[0]?.organizationId || "");
-  const branchInfo = await github.getBranchInfo({
-    owner: repoInfo.owner,
-    repo: repoInfo.repo,
-    branch: "main"
-  });
-  if (!branchInfo) {
-    throw new Error("Could not get repository branch info");
-  }
-  const project = await prisma2.project.create({
-    data: {
-      name,
-      description,
-      type: ProjectType.PERSONAL,
-      origin: ProjectOrigin.CREATED,
-      ownerId: userId,
-      organizationId: null,
-      repositoryUrl,
-      baseBranch: "main"
-    }
-  });
-  return {
-    success: true,
-    projectId: project.id
-  };
-}
-
-export {
-  createMCPServer
-};
-//# sourceMappingURL=chunk-7YL3QGGO.js.map