@mtaap/mcp 0.1.2 → 0.1.3

package/dist/{chunk-4ILBJI7A.js → chunk-7YL3QGGO.js}

@@ -1,318 +1,919 @@
-import {
-  dist_exports,
-  prisma
-} from "./chunk-IEQQVLM4.js";
-import {
-  AbandonTaskInputSchema,
-  AddNoteInputSchema,
-  ApiKeyPermission,
-  AssignTaskInputSchema,
-  CompleteTaskInputSchema,
-  CreatePersonalProjectInputSchema,
-  GetProjectContextInputSchema,
-  GetTaskInputSchema,
-  ListProjectsInputSchema,
-  ListTasksInputSchema,
-  ProjectOrigin,
-  ProjectType,
-  ReportErrorInputSchema,
-  TaskState,
-  UpdateProgressInputSchema,
-  UserRole,
-  z
-} from "./chunk-ASNGTDTC.js";
+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/auth/dist/nextauth.js
-import Credentials from "next-auth/providers/credentials";
+// ../../packages/db/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  prisma: () => prisma2
+});
 
-// ../../packages/auth/dist/ldap.js
-async function authenticateWithLdap(email, password, organizationId) {
-  const settings = await prisma.organizationSettings.findUnique({
-    where: { organizationId }
-  });
-  if (!settings?.ldapEnabled || !settings.ldapUrl) {
-    return null;
+// ../../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
   }
-  const config = {
-    url: settings.ldapUrl,
-    bindDN: settings.ldapBindDN || "",
-    searchBase: settings.ldapSearchBase || ""
-  };
-  return performLdapAuth(email, password, config);
+};
+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(",");
 }
-async function performLdapAuth(email, password, config) {
-  const ldapjs = await import("ldapjs");
-  return new Promise((resolve) => {
-    const client = ldapjs.createClient({
-      url: config.url,
-      timeout: 5e3,
-      connectTimeout: 1e4
-    });
-    client.on("error", (err) => {
-      console.error("LDAP connection error:", err.message);
-      resolve(null);
-    });
-    const usernameAttr = "mail";
-    const searchFilter = `(${usernameAttr}=${ldapEscape(email)})`;
-    const searchOptions = {
-      filter: searchFilter,
-      scope: "sub",
-      attributes: ["dn", "mail", "cn", "displayName", "givenName", "sn"]
-    };
-    if (config.bindDN) {
-      client.bind(config.bindDN, "", (bindErr) => {
-        if (bindErr) {
-          console.error("LDAP service bind failed:", bindErr.message);
-          client.unbind();
-          resolve(null);
-          return;
-        }
-        searchAndBind(client, config.searchBase, searchOptions, password, resolve);
-      });
-    } else {
-      searchAndBind(client, config.searchBase, searchOptions, password, resolve);
+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 searchAndBind(client, searchBase, searchOptions, password, resolve) {
-  client.search(searchBase, searchOptions, (searchErr, searchRes) => {
-    if (searchErr) {
-      console.error("LDAP search error:", searchErr.message);
-      client.unbind();
-      resolve(null);
-      return;
+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);
     }
-    let userEntry = null;
-    searchRes.on("searchEntry", (entry) => {
-      const dn = entry.dn.toString();
-      const attrs = entry.attributes;
-      const mail = getAttrValue(attrs, "mail");
-      const displayName = getAttrValue(attrs, "displayName");
-      const cn = getAttrValue(attrs, "cn");
-      const givenName = getAttrValue(attrs, "givenName");
-      const sn = getAttrValue(attrs, "sn");
-      const name = displayName || cn || [givenName, sn].filter(Boolean).join(" ") || mail;
-      userEntry = {
-        email: mail || "",
-        name: name || "",
-        dn
-      };
-    });
-    searchRes.on("error", (err) => {
-      console.error("LDAP search result error:", err.message);
-      client.unbind();
-      resolve(null);
-    });
-    searchRes.on("end", () => {
-      if (!userEntry) {
-        client.unbind();
-        resolve(null);
-        return;
-      }
-      const userDn = userEntry.dn;
-      const foundUser = userEntry;
-      client.bind(userDn, password, (authErr) => {
-        client.unbind();
-        if (authErr) {
-          console.error("LDAP user bind failed:", authErr.message);
-          resolve(null);
-          return;
+  };
+}
+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);
         }
-        resolve(foundUser);
-      });
-    });
-  });
+      }
+      const infKey = `${baseKey}|le="+Inf"`;
+      data.values.set(infKey, (data.values.get(infKey) || 0) + 1);
+    }
+  };
 }
-function getAttrValue(attrs, name) {
-  const attr = attrs.find((a) => a.type.toLowerCase() === name.toLowerCase());
-  if (!attr || !attr.values || attr.values.length === 0) {
-    return void 0;
-  }
-  const val = attr.values[0];
-  if (typeof val === "string")
-    return val;
-  if (val && typeof val === "object" && "toString" in val) {
-    return val.toString();
+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
   }
-  return void 0;
+};
+function cloneThresholds() {
+  return Object.fromEntries(Object.entries(DEFAULT_THRESHOLDS).map(([category, metrics2]) => [
+    category,
+    { ...metrics2 }
+  ]));
 }
-function ldapEscape(str) {
-  return str.replace(/[\\*()]/g, (char) => `\\${char.charCodeAt(0).toString(16)}`);
+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(",");
 }
-async function getOrganizationLdapConfig(organizationSlug) {
-  const org = await prisma.organization.findUnique({
-    where: { slug: organizationSlug },
-    include: { settings: true }
-  });
-  if (!org) {
-    return null;
-  }
-  return {
-    enabled: org.settings?.ldapEnabled ?? false,
-    organizationId: org.id
-  };
+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];
 }
-async function findOrCreateLdapUser(ldapUser, organizationId) {
-  let user = await prisma.user.findUnique({
-    where: { email: ldapUser.email }
-  });
-  if (!user) {
-    const crypto = await import("crypto");
-    const randomPassword = crypto.randomBytes(32).toString("hex");
-    const bcrypt = await import("bcryptjs");
-    const passwordHash = await bcrypt.hash(randomPassword, 10);
-    user = await prisma.user.create({
-      data: {
-        email: ldapUser.email,
-        name: ldapUser.name,
-        passwordHash,
-        role: UserRole.MEMBER
-      }
-    });
+var CircularBuffer = class {
+  capacity;
+  values = [];
+  index = 0;
+  size = 0;
+  constructor(capacity) {
+    this.capacity = capacity;
   }
-  const membership = await prisma.organizationUser.findFirst({
-    where: {
-      userId: user.id,
-      organizationId
+  add(value) {
+    if (this.size < this.capacity) {
+      this.values.push(value);
+      this.size += 1;
+      this.index = this.size % this.capacity;
+      return;
     }
-  });
-  if (!membership) {
-    const subscription = await prisma.subscription.findUnique({
-      where: { organizationId }
-    });
-    if (subscription && subscription.seats > 0) {
-      const currentSeats = await prisma.organizationUser.count({
-        where: { organizationId }
-      });
-      if (currentSeats >= subscription.seats) {
-        throw new Error("No available seats in organization subscription");
-      }
+    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);
     }
-    await prisma.organizationUser.create({
-      data: {
-        userId: user.id,
-        organizationId,
-        roleId: UserRole.MEMBER
-      }
-    });
+    return this.values.slice();
   }
-  return {
-    id: user.id,
-    email: user.email,
-    name: user.name
-  };
-}
-
-// ../../packages/auth/dist/nextauth.js
-var THIRTY_DAYS_IN_SECONDS = 30 * 24 * 60 * 60;
-var authConfig = {
-  providers: [
-    Credentials({
-      name: "credentials",
-      credentials: {
-        email: { label: "Email", type: "email" },
-        password: { label: "Password", type: "password" },
-        organizationSlug: { label: "Organization", type: "text" }
-      },
-      async authorize(credentials) {
-        const parsed = z.object({
-          email: z.string().email(),
-          password: z.string().min(8),
-          organizationSlug: z.string().optional()
-        }).safeParse(credentials);
-        if (!parsed.success) {
-          return null;
-        }
-        const { email, password, organizationSlug } = parsed.data;
-        if (organizationSlug) {
-          const ldapConfig = await getOrganizationLdapConfig(organizationSlug);
-          if (ldapConfig?.enabled) {
-            const ldapUser = await authenticateWithLdap(email, password, ldapConfig.organizationId);
-            if (ldapUser) {
-              const user2 = await findOrCreateLdapUser(ldapUser, ldapConfig.organizationId);
-              return {
-                id: user2.id,
-                email: user2.email,
-                name: user2.name,
-                role: UserRole.MEMBER,
-                organizationId: ldapConfig.organizationId
-              };
-            }
-            return null;
-          }
-        }
-        const whereClause = {};
-        if (organizationSlug) {
-          whereClause.organization = {
-            slug: organizationSlug
+};
+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
           };
-        }
-        const user = await prisma.user.findUnique({
-          where: { email },
-          include: {
-            organizations: {
-              where: whereClause,
-              take: 1
-            }
+          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 (!user) {
-          return null;
-        }
-        const bcrypt = await import("bcryptjs");
-        const isValid = await bcrypt.compare(password, user.passwordHash);
-        if (!isValid) {
-          return null;
         }
-        const orgUser = user.organizations?.[0];
-        const role = orgUser ? orgUser.roleId : UserRole.MEMBER;
-        return {
-          id: user.id,
-          email: user.email,
-          name: user.name,
-          role,
-          organizationId: orgUser?.organizationId
-        };
       }
-    })
-  ],
-  session: {
-    strategy: "jwt",
-    maxAge: THIRTY_DAYS_IN_SECONDS
-  },
-  pages: {
-    signIn: "/auth/signin",
-    error: "/auth/error"
-  },
-  callbacks: {
-    async jwt({ token, user }) {
-      if (user) {
-        token.id = user.id;
-        token.role = user.role;
-        token.organizationId = user.organizationId;
+    }
+    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 token;
-    },
-    async session({ session, token }) {
-      if (token) {
-        session.user = {
-          ...session.user,
-          id: token.id,
-          role: token.role,
-          organizationId: token.organizationId
-        };
+    }
+    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 });
+        }
       }
-      return session;
     }
   }
+});
+
+// ../../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 prisma.apiKey.findFirst({
+  const keyRecord = await prisma2.apiKey.findFirst({
     where: {
       keyHash,
       revoked: false
@@ -333,7 +934,7 @@ async function validateApiKey(apiKey) {
   if (!keyRecord || keyRecord.expiresAt && keyRecord.expiresAt < /* @__PURE__ */ new Date()) {
     return null;
   }
-  await prisma.apiKey.update({
+  await prisma2.apiKey.update({
     where: { id: keyRecord.id },
     data: { lastUsedAt: /* @__PURE__ */ new Date() }
   });
@@ -341,30 +942,19 @@ async function validateApiKey(apiKey) {
   return {
     user: keyRecord.user,
     organization: orgUser?.organization,
-    apiKey: keyRecord
+    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
+    }
   };
 }
-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");
-}
-
-// ../../packages/auth/dist/stateMachine.js
-var VALID_TRANSITIONS = {
-  [TaskState.BACKLOG]: [TaskState.READY],
-  [TaskState.READY]: [TaskState.IN_PROGRESS],
-  [TaskState.IN_PROGRESS]: [TaskState.REVIEW],
-  [TaskState.REVIEW]: [TaskState.DONE, TaskState.IN_PROGRESS],
-  [TaskState.DONE]: []
-};
 
 // src/version.ts
-var VERSION = "0.1.2";
+var VERSION2 = "0.1.3";
 
 // ../../packages/git/dist/github.js
 import { Octokit } from "octokit";
@@ -665,7 +1255,7 @@ async function getAuthenticatedUser(apiKey) {
 }
 async function ensureAccessControl(projectId, userId, organizationId) {
   if (!organizationId) {
-    const project = await prisma.project.findUnique({
+    const project = await prisma2.project.findUnique({
       where: { id: projectId },
       include: { owner: true }
     });
@@ -675,7 +1265,7 @@ async function ensureAccessControl(projectId, userId, organizationId) {
       );
     }
   } else {
-    const project = await prisma.project.findUnique({
+    const project = await prisma2.project.findUnique({
       where: { id: projectId },
       include: { organization: true }
     });
@@ -684,11 +1274,11 @@ async function ensureAccessControl(projectId, userId, organizationId) {
         "Access denied: You do not have permission to access this project"
       );
     }
-    const userTags = await prisma.userTag.findMany({
+    const userTags = await prisma2.userTag.findMany({
       where: { userId },
       include: { tag: true }
     });
-    const projectTags = await prisma.projectTag.findMany({
+    const projectTags = await prisma2.projectTag.findMany({
       where: { projectId },
       include: { tag: true }
     });
@@ -719,7 +1309,7 @@ function slugify(text, maxLength = 50) {
 async function createMCPServer() {
   const server = new McpServer({
     name: "mtaap",
-    version: VERSION
+    version: VERSION2
   });
   const apiKey = process.env.MTAAP_API_KEY;
   if (!apiKey) {
@@ -1072,7 +1662,7 @@ async function createMCPServer() {
             type: "text",
             text: JSON.stringify(
               {
-                version: VERSION,
+                version: VERSION2,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               },
               null,
@@ -1103,7 +1693,7 @@ async function listProjects(userId, organizationId, workspaceType = "ALL") {
       include: { tag: true }
     };
   }
-  const projects = await prisma.project.findMany({
+  const projects = await prisma2.project.findMany({
     where,
     include,
     orderBy: { updatedAt: "desc" }
@@ -1137,7 +1727,7 @@ async function listTasks(userId, organizationId, projectId, state, assigneeId) {
   if (assigneeId) {
     where.assigneeId = assigneeId;
   }
-  const tasks = await prisma.task.findMany({
+  const tasks = await prisma2.task.findMany({
     where,
     include: {
       project: true,
@@ -1149,7 +1739,7 @@ async function listTasks(userId, organizationId, projectId, state, assigneeId) {
   });
   const formattedTasks = await Promise.all(
     tasks.map(async (task) => {
-      const acceptanceCriteria = await prisma.acceptanceCriterion.findMany({
+      const acceptanceCriteria = await prisma2.acceptanceCriterion.findMany({
         where: { taskId: task.id },
         orderBy: { order: "asc" }
       });
@@ -1191,7 +1781,7 @@ async function listTasks(userId, organizationId, projectId, state, assigneeId) {
   return formattedTasks;
 }
 async function getTaskWithChecks(taskId, userId, organizationId) {
-  const task = await prisma.task.findUnique({
+  const task = await prisma2.task.findUnique({
     where: { id: taskId },
     include: {
       project: {
@@ -1222,7 +1812,7 @@ async function getTaskWithChecks(taskId, userId, organizationId) {
     throw new Error("Task not found");
   }
   if (organizationId && task.project?.organizationId !== organizationId) {
-    const userTags = await prisma.userTag.findMany({
+    const userTags = await prisma2.userTag.findMany({
       where: { userId },
       include: { tag: true }
     });
@@ -1295,7 +1885,7 @@ async function getTaskWithChecks(taskId, userId, organizationId) {
 }
 async function assignTask(projectId, taskId, userId, organizationId, expectedState = TaskState.READY) {
   await ensureAccessControl(projectId, userId, organizationId);
-  const task = await prisma.task.findUnique({
+  const task = await prisma2.task.findUnique({
     where: { id: taskId },
     include: { project: true }
   });
@@ -1328,7 +1918,7 @@ async function assignTask(projectId, taskId, userId, organizationId, expectedSta
   if (!createResult.success) {
     throw new Error(`Failed to create branch: ${createResult.error}`);
   }
-  const updatedTask = await prisma.task.update({
+  const updatedTask = await prisma2.task.update({
     where: { id: taskId },
     data: {
       state: TaskState.IN_PROGRESS,
@@ -1345,7 +1935,7 @@ async function assignTask(projectId, taskId, userId, organizationId, expectedSta
   };
 }
 async function updateProgress(taskId, userId, statusMessage, completedCheckpointIds, _currentCheckpointIndex) {
-  const task = await prisma.task.findUnique({
+  const task = await prisma2.task.findUnique({
     where: { id: taskId }
   });
   if (!task) {
@@ -1355,7 +1945,7 @@ async function updateProgress(taskId, userId, statusMessage, completedCheckpoint
     throw new Error("You are not assigned to this task");
   }
   if (completedCheckpointIds && completedCheckpointIds.length > 0) {
-    await prisma.acceptanceCriterion.updateMany({
+    await prisma2.acceptanceCriterion.updateMany({
       where: {
         id: { in: completedCheckpointIds }
       },
@@ -1366,7 +1956,7 @@ async function updateProgress(taskId, userId, statusMessage, completedCheckpoint
     });
   }
   if (statusMessage) {
-    await prisma.progressUpdate.create({
+    await prisma2.progressUpdate.create({
       data: {
         taskId,
         userId,
@@ -1375,7 +1965,7 @@ async function updateProgress(taskId, userId, statusMessage, completedCheckpoint
       }
     });
   }
-  const updatedTask = await prisma.task.update({
+  const updatedTask = await prisma2.task.update({
     where: { id: taskId },
     data: {
       updatedAt: /* @__PURE__ */ new Date()
@@ -1388,7 +1978,7 @@ async function updateProgress(taskId, userId, statusMessage, completedCheckpoint
 }
 async function completeTask(projectId, taskId, userId, organizationId, pullRequestTitle, pullRequestBody) {
   await ensureAccessControl(projectId, userId, organizationId);
-  const task = await prisma.task.findUnique({
+  const task = await prisma2.task.findUnique({
     where: { id: taskId },
     include: { project: true }
   });
@@ -1411,7 +2001,7 @@ async function completeTask(projectId, taskId, userId, organizationId, pullReque
     throw new Error("Invalid repository URL");
   }
   const github = getGitHubClient(task.project?.organizationId || "");
-  const acceptanceCriteria = await prisma.acceptanceCriterion.findMany({
+  const acceptanceCriteria = await prisma2.acceptanceCriterion.findMany({
     where: { taskId },
     orderBy: { order: "asc" }
   });
@@ -1435,7 +2025,7 @@ ${acceptanceChecklist}`;
   if (!createResult.success) {
     throw new Error(`Failed to create PR: ${createResult.error}`);
   }
-  const updatedTask = await prisma.task.update({
+  const updatedTask = await prisma2.task.update({
     where: { id: taskId },
     data: {
       state: TaskState.REVIEW,
@@ -1469,7 +2059,7 @@ async function checkActiveTask() {
   };
 }
 async function reportTaskError(taskId, userId, errorType, errorMessage, _context) {
-  const task = await prisma.task.findUnique({
+  const task = await prisma2.task.findUnique({
     where: { id: taskId }
   });
   if (!task) {
@@ -1478,7 +2068,7 @@ async function reportTaskError(taskId, userId, errorType, errorMessage, _context
   if (task.assigneeId !== userId) {
     throw new Error("You are not assigned to this task");
   }
-  const updatedTask = await prisma.task.update({
+  const updatedTask = await prisma2.task.update({
     where: { id: taskId },
     data: {
       errorType,
@@ -1491,7 +2081,7 @@ async function reportTaskError(taskId, userId, errorType, errorMessage, _context
   };
 }
 async function getProjectContext(projectId) {
-  const project = await prisma.project.findUnique({
+  const project = await prisma2.project.findUnique({
     where: { id: projectId },
     include: {
       organization: {
@@ -1525,7 +2115,7 @@ async function getProjectContext(projectId) {
       stack = Object.keys(deps).slice(0, 20);
     }
   }
-  const recentCompletedTasks = await prisma.task.findMany({
+  const recentCompletedTasks = await prisma2.task.findMany({
     where: {
       project: {
         id: projectId
@@ -1561,7 +2151,7 @@ async function getProjectContext(projectId) {
   };
 }
 async function addTaskNote(taskId, userId, content) {
-  const task = await prisma.task.findUnique({
+  const task = await prisma2.task.findUnique({
     where: { id: taskId }
   });
   if (!task) {
@@ -1570,7 +2160,7 @@ async function addTaskNote(taskId, userId, content) {
   if (task.assigneeId !== userId) {
     throw new Error("You are not assigned to this task");
   }
-  const note = await prisma.taskNote.create({
+  const note = await prisma2.taskNote.create({
     data: {
       taskId,
       userId,
@@ -1583,7 +2173,7 @@ async function addTaskNote(taskId, userId, content) {
   };
 }
 async function abandonTask(taskId, projectId, userId, deleteBranch) {
-  const task = await prisma.task.findUnique({
+  const task = await prisma2.task.findUnique({
     where: { id: taskId },
     include: { project: true }
   });
@@ -1616,7 +2206,7 @@ async function abandonTask(taskId, projectId, userId, deleteBranch) {
     }
   }
   const newState = task.state === TaskState.IN_PROGRESS ? TaskState.READY : task.state;
-  const updatedTask = await prisma.task.update({
+  const updatedTask = await prisma2.task.update({
     where: { id: taskId },
     data: {
       state: newState,
@@ -1634,7 +2224,7 @@ async function abandonTask(taskId, projectId, userId, deleteBranch) {
   };
 }
 async function createPersonalProject(userId, name, description, repositoryUrl) {
-  const user = await prisma.user.findUnique({
+  const user = await prisma2.user.findUnique({
     where: { id: userId },
     include: { organizations: true }
   });
@@ -1654,7 +2244,7 @@ async function createPersonalProject(userId, name, description, repositoryUrl) {
   if (!branchInfo) {
     throw new Error("Could not get repository branch info");
   }
-  const project = await prisma.project.create({
+  const project = await prisma2.project.create({
     data: {
       name,
       description,
@@ -1675,4 +2265,4 @@ async function createPersonalProject(userId, name, description, repositoryUrl) {
 export {
   createMCPServer
 };
-//# sourceMappingURL=chunk-4ILBJI7A.js.map
+//# sourceMappingURL=chunk-7YL3QGGO.js.map