@iloom/cli 0.11.1 → 0.13.0-beta.0

package/dist/mcp/issue-management-server.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   logger
-} from "./chunk-PIIRD4LO.js";
+} from "./chunk-4HZMW2V3.js";
 
 // src/mcp/issue-management-server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -2398,7 +2398,7 @@ async function promptConfirmation(message, defaultValue = false) {
 }
 
 // src/lib/providers/jira/JiraIssueTracker.ts
-var JiraIssueTracker = class {
+var JiraIssueTracker = class _JiraIssueTracker {
   constructor(config, options) {
     this.providerName = "jira";
     this.supportsPullRequests = false;
@@ -2410,6 +2410,36 @@ var JiraIssueTracker = class {
     });
     this.prompter = (options == null ? void 0 : options.prompter) ?? promptConfirmation;
   }
+  /**
+   * Create a JiraIssueTracker from IloomSettings
+   * Extracts and validates Jira config from settings
+   */
+  static fromSettings(settings2) {
+    var _a;
+    const jiraSettings = (_a = settings2.issueManagement) == null ? void 0 : _a.jira;
+    if (!(jiraSettings == null ? void 0 : jiraSettings.host)) {
+      throw new Error("Jira host is required. Configure issueManagement.jira.host in .iloom/settings.json");
+    }
+    if (!(jiraSettings == null ? void 0 : jiraSettings.username)) {
+      throw new Error("Jira username is required. Configure issueManagement.jira.username in .iloom/settings.json");
+    }
+    if (!(jiraSettings == null ? void 0 : jiraSettings.apiToken)) {
+      throw new Error("Jira API token is required. Configure issueManagement.jira.apiToken in .iloom/settings.local.json");
+    }
+    if (!(jiraSettings == null ? void 0 : jiraSettings.projectKey)) {
+      throw new Error("Jira project key is required. Configure issueManagement.jira.projectKey in .iloom/settings.json");
+    }
+    const config = {
+      host: jiraSettings.host,
+      username: jiraSettings.username,
+      apiToken: jiraSettings.apiToken,
+      projectKey: jiraSettings.projectKey
+    };
+    if (jiraSettings.transitionMappings) {
+      config.transitionMappings = jiraSettings.transitionMappings;
+    }
+    return new _JiraIssueTracker(config);
+  }
   /**
    * Normalize identifier to canonical uppercase form
    * Jira issue keys are case-sensitive in the API (must be uppercase)
@@ -2723,6 +2753,11 @@ import path2 from "path";
 import os2 from "os";
 import { z } from "zod";
 import deepmerge from "deepmerge";
+var mergeModeValues = ["local", "pr", "draft-pr", "github-pr", "github-draft-pr", "bitbucket-pr"];
+var mergeModeTransform = (val) => {
+  const map = { "github-pr": "pr", "github-draft-pr": "draft-pr", "bitbucket-pr": "pr" };
+  return map[val] ?? val;
+};
 var BaseAgentSettingsSchema = z.object({
   model: z.enum(["sonnet", "opus", "haiku"]).optional().describe("Claude model shorthand: sonnet, opus, or haiku"),
   swarmModel: z.enum(["sonnet", "opus", "haiku"]).optional().describe("Model to use for this agent in swarm mode. Overrides the base model when running inside swarm workers."),
@@ -2734,9 +2769,7 @@ var BaseAgentSettingsSchema = z.object({
   review: z.boolean().optional().describe("Whether artifacts from this agent should be reviewed before posting (defaults to false)"),
   swarmReview: z.boolean().optional().describe("Whether artifacts from this agent should be reviewed in swarm mode. Defaults to false if not set (review is off in swarm mode for speed and cost unless explicitly enabled).")
 });
-var AgentSettingsSchema = BaseAgentSettingsSchema.extend({
-  subAgentTimeout: z.number().min(1, "Sub-agent timeout must be at least 1 minute").max(120, "Sub-agent timeout cannot exceed 120 minutes").default(10).describe("Timeout in minutes for sub-agent claude -p invocations in swarm mode. Applies to each phase agent (evaluator, analyzer, planner, implementer) when invoked via the Bash tool. Default: 10 minutes. Only meaningful under the iloom-swarm-worker agent entry.")
-});
+var AgentSettingsSchema = BaseAgentSettingsSchema;
 var SpinAgentSettingsSchema = z.object({
   model: z.enum(["sonnet", "opus", "haiku"]).default("opus").describe("Claude model shorthand for spin orchestrator"),
   swarmModel: z.enum(["sonnet", "opus", "haiku"]).optional().describe("Model for the spin orchestrator when running in swarm mode. Overrides spin.model for swarm workflows."),
@@ -2745,7 +2778,8 @@ var SpinAgentSettingsSchema = z.object({
 var PlanCommandSettingsSchema = z.object({
   model: z.enum(["sonnet", "opus", "haiku"]).default("opus").describe("Claude model shorthand for plan command"),
   planner: z.enum(["claude", "gemini", "codex"]).default("claude").describe("AI provider for creating the plan"),
-  reviewer: z.enum(["claude", "gemini", "codex", "none"]).default("none").describe("AI provider for reviewing the plan (none to skip review)")
+  reviewer: z.enum(["claude", "gemini", "codex", "none"]).default("none").describe("AI provider for reviewing the plan (none to skip review)"),
+  waveVerification: z.boolean().default(true).describe("When enabled, the planner generates verification child issues between dependency waves to catch integration issues early.")
 });
 var SummarySettingsSchema = z.object({
   model: z.enum(["sonnet", "opus", "haiku"]).default("sonnet").describe("Claude model shorthand for session summary generation")
@@ -2780,7 +2814,12 @@ var WorkflowsSettingsSchemaNoDefaults = z.object({
 }).optional();
 var CapabilitiesSettingsSchema = z.object({
   web: z.object({
-    basePort: z.number().min(1, "Base port must be >= 1").max(65535, "Base port must be <= 65535").optional().describe("Base port for web workspace port calculations (default: 3000)")
+    basePort: z.number().min(1, "Base port must be >= 1").max(65535, "Base port must be <= 65535").optional().describe("Base port for web workspace port calculations (default: 3000)"),
+    devServer: z.enum(["process", "docker"]).default("process").describe('Dev server mode: "process" runs natively, "docker" runs inside a Docker container with port mapping'),
+    dockerFile: z.string().default("./Dockerfile").describe('Path to Dockerfile relative to worktree root (only used when devServer is "docker")'),
+    containerPort: z.number().min(1, "Container port must be >= 1").max(65535, "Container port must be <= 65535").optional().describe("Port the app runs on inside the Docker container (auto-detected from EXPOSE directive if not set)"),
+    dockerBuildArgs: z.record(z.string()).optional().describe('Build arguments to pass to docker build (e.g., {"NODE_ENV": "development"})'),
+    dockerRunArgs: z.array(z.string()).optional().describe('Additional arguments for docker run (e.g., ["-v", "./src:/app/src"] for volume mounts)')
   }).optional().describe('Web dev server settings. To declare a project as a web project, add "web" to the capabilities array in .iloom/package.iloom.json or .iloom/package.iloom.local.json.'),
   database: z.object({
     databaseUrlEnvVarName: z.string().min(1, "Database URL variable name cannot be empty").regex(/^[A-Z_][A-Z0-9_]*$/, "Must be valid env var name (uppercase, underscores)").optional().default("DATABASE_URL").describe("Name of environment variable for database connection URL")
@@ -2788,19 +2827,71 @@ var CapabilitiesSettingsSchema = z.object({
 }).optional();
 var CapabilitiesSettingsSchemaNoDefaults = z.object({
   web: z.object({
-    basePort: z.number().min(1, "Base port must be >= 1").max(65535, "Base port must be <= 65535").optional().describe("Base port for web workspace port calculations (default: 3000)")
+    basePort: z.number().min(1, "Base port must be >= 1").max(65535, "Base port must be <= 65535").optional().describe("Base port for web workspace port calculations (default: 3000)"),
+    devServer: z.enum(["process", "docker"]).optional().describe('Dev server mode: "process" runs natively, "docker" runs inside a Docker container with port mapping'),
+    dockerFile: z.string().optional().describe('Path to Dockerfile relative to worktree root (only used when devServer is "docker")'),
+    containerPort: z.number().min(1, "Container port must be >= 1").max(65535, "Container port must be <= 65535").optional().describe("Port the app runs on inside the Docker container (auto-detected from EXPOSE directive if not set)"),
+    dockerBuildArgs: z.record(z.string()).optional().describe('Build arguments to pass to docker build (e.g., {"NODE_ENV": "development"})'),
+    dockerRunArgs: z.array(z.string()).optional().describe('Additional arguments for docker run (e.g., ["-v", "./src:/app/src"] for volume mounts)')
   }).optional().describe('Web dev server settings. To declare a project as a web project, add "web" to the capabilities array in .iloom/package.iloom.json or .iloom/package.iloom.local.json.'),
   database: z.object({
     databaseUrlEnvVarName: z.string().min(1, "Database URL variable name cannot be empty").regex(/^[A-Z_][A-Z0-9_]*$/, "Must be valid env var name (uppercase, underscores)").optional().describe("Name of environment variable for database connection URL")
   }).optional()
 }).optional();
+var DevServerSettingsSchema = z.object({
+  mode: z.enum(["docker"]).default("docker").describe('Dev server mode. Currently only "docker" is supported.'),
+  docker: z.object({
+    dockerFile: z.string().default("./Dockerfile").refine(
+      (val) => {
+        if (path2.isAbsolute(val)) return false;
+        const normalized = path2.normalize(val);
+        if (normalized.startsWith("..")) return false;
+        return true;
+      },
+      {
+        message: 'dockerFile must be a relative path that does not traverse outside the project root (no leading "/" and no "../" escaping)'
+      }
+    ).describe("Path to Dockerfile relative to worktree root"),
+    containerPort: z.number().min(1, "Container port must be >= 1").max(65535, "Container port must be <= 65535").optional().describe("Port the app runs on inside the Docker container (auto-detected from EXPOSE directive if not set)"),
+    buildArgs: z.record(z.string(), z.string()).optional().describe("Build arguments to pass to docker build"),
+    runArgs: z.array(z.string()).optional().describe("Additional arguments for docker run")
+  }).optional()
+});
+var DevServerSettingsSchemaNoDefaults = z.object({
+  mode: z.enum(["docker"]).optional().describe('Dev server mode. Currently only "docker" is supported.'),
+  docker: z.object({
+    dockerFile: z.string().optional().refine(
+      (val) => {
+        if (val === void 0) return true;
+        if (path2.isAbsolute(val)) return false;
+        const normalized = path2.normalize(val);
+        if (normalized.startsWith("..")) return false;
+        return true;
+      },
+      {
+        message: 'dockerFile must be a relative path that does not traverse outside the project root (no leading "/" and no "../" escaping)'
+      }
+    ).describe("Path to Dockerfile relative to worktree root"),
+    containerPort: z.number().min(1, "Container port must be >= 1").max(65535, "Container port must be <= 65535").optional().describe("Port the app runs on inside the Docker container (auto-detected from EXPOSE directive if not set)"),
+    buildArgs: z.record(z.string(), z.string()).optional().describe("Build arguments to pass to docker build"),
+    runArgs: z.array(z.string()).optional().describe("Additional arguments for docker run")
+  }).optional()
+});
 var NeonSettingsSchema = z.object({
   projectId: z.string().min(1).regex(/^[a-zA-Z0-9-]+$/, "Neon project ID must contain only letters, numbers, and hyphens").describe('Neon project ID found in your project URL (e.g., "fantastic-fox-3566354")'),
   parentBranch: z.string().min(1).describe("Branch from which new database branches are created")
 });
+var SupabaseSettingsSchema = z.object({
+  projectRef: z.string().min(1).describe('Supabase project reference ID (e.g., "abcdefghijklmnop")'),
+  parentBranch: z.string().min(1).optional().describe("Reserved for future use. Supabase currently always branches from the default branch."),
+  withData: z.boolean().optional().describe("Whether to include data when creating a new branch (defaults to true)")
+});
 var DatabaseProvidersSettingsSchema = z.object({
   neon: NeonSettingsSchema.optional().describe(
     "Neon database configuration. Requires Neon CLI installed and authenticated for database branching."
+  ),
+  supabase: SupabaseSettingsSchema.optional().describe(
+    "Supabase database configuration. Requires Supabase CLI installed and authenticated for database branching."
   )
 }).optional();
 var IloomSettingsSchema = z.object({
@@ -2845,6 +2936,7 @@ var IloomSettingsSchema = z.object({
     "Session summary generation configuration. Model defaults to sonnet when not configured."
   ),
   capabilities: CapabilitiesSettingsSchema.describe("Project capability configurations"),
+  devServer: DevServerSettingsSchema.optional().describe("Docker-based dev server configuration"),
   databaseProviders: DatabaseProvidersSettingsSchema.describe("Database provider configurations"),
   issueManagement: z.object({
     // SYNC: If this default changes, update displayDefaultsBox() in src/utils/first-run-setup.ts
@@ -2869,17 +2961,28 @@ var IloomSettingsSchema = z.object({
       doneStatuses: z.array(z.string()).optional().default(["Done"]).describe('Status names to exclude from issue lists (e.g., ["Done", "Closed", "Verify"])')
     }).optional()
   }).optional().describe("Issue management configuration"),
+  versionControl: z.object({
+    provider: z.enum(["github", "bitbucket"]).optional().default("github").describe("Version control provider (github, bitbucket)"),
+    bitbucket: z.object({
+      username: z.string().min(1, "BitBucket username cannot be empty").describe("BitBucket username"),
+      apiToken: z.string().optional().describe("BitBucket API token. SECURITY: Store in settings.local.json only, never commit to source control. Generate at: https://bitbucket.org/account/settings/app-passwords/ (Note: App passwords deprecated Sep 2025, use API tokens)"),
+      workspace: z.string().optional().describe("BitBucket workspace (optional, auto-detected from git remote if not provided)"),
+      repoSlug: z.string().optional().describe("BitBucket repository slug (optional, auto-detected from git remote if not provided)"),
+      reviewers: z.array(z.string().describe("Reviewer username")).optional().describe("List of usernames to add as PR reviewers. Usernames are resolved to Bitbucket account IDs at PR creation time.")
+    }).optional()
+  }).optional().describe("Version control provider configuration"),
   mergeBehavior: z.object({
     // SYNC: If this default changes, update displayDefaultsBox() in src/utils/first-run-setup.ts
-    mode: z.enum(["local", "github-pr", "github-draft-pr"]).default("local"),
+    mode: z.enum(mergeModeValues).default("local").transform(mergeModeTransform),
     remote: z.string().optional(),
     autoCommitPush: z.boolean().optional().describe(
-      "Auto-commit and push after code review in draft PR mode. Defaults to true when mode is github-draft-pr."
+      "Auto-commit and push after code review in draft PR mode. Defaults to true when mode is draft-pr."
     ),
+    prTitlePrefix: z.boolean().default(false).optional().describe('Prefix PR titles with the issue number (e.g., "QLH-123: Title"). Default: false'),
     openBrowserOnFinish: z.boolean().default(true).describe(
-      "Open the PR in the default browser after finishing in github-pr or github-draft-pr mode. Use --no-browser flag to override."
+      "Open the PR in the default browser after finishing in pr or draft-pr mode. Use --no-browser flag to override."
     )
-  }).optional().describe("Merge behavior configuration: local (merge locally), github-pr (create PR), or github-draft-pr (create draft PR at start, mark ready on finish)"),
+  }).optional().describe("Merge behavior configuration: local (merge locally), pr (create PR), or draft-pr (create draft PR at start, mark ready on finish)"),
   ide: z.object({
     // SYNC: If this default changes, update displayDefaultsBox() in src/utils/first-run-setup.ts
     type: z.enum(["vscode", "cursor", "webstorm", "sublime", "intellij", "windsurf", "antigravity"]).default("vscode").describe(
@@ -2941,12 +3044,14 @@ var IloomSettingsSchemaNoDefaults = z.object({
   plan: z.object({
     model: z.enum(["sonnet", "opus", "haiku"]).optional(),
     planner: z.enum(["claude", "gemini", "codex"]).optional(),
-    reviewer: z.enum(["claude", "gemini", "codex", "none"]).optional()
+    reviewer: z.enum(["claude", "gemini", "codex", "none"]).optional(),
+    waveVerification: z.boolean().optional()
   }).optional().describe("Plan command configuration"),
   summary: z.object({
     model: z.enum(["sonnet", "opus", "haiku"]).optional()
   }).optional().describe("Session summary generation configuration"),
   capabilities: CapabilitiesSettingsSchemaNoDefaults.describe("Project capability configurations"),
+  devServer: DevServerSettingsSchemaNoDefaults.optional().describe("Docker-based dev server configuration"),
   databaseProviders: DatabaseProvidersSettingsSchema.describe("Database provider configurations"),
   issueManagement: z.object({
     provider: z.enum(["github", "linear", "jira"]).optional().describe("Issue tracker provider (github, linear, jira)"),
@@ -2970,16 +3075,27 @@ var IloomSettingsSchemaNoDefaults = z.object({
       doneStatuses: z.array(z.string()).optional().default(["Done"]).describe('Status names to exclude from issue lists (e.g., ["Done", "Closed", "Verify"])')
     }).optional()
   }).optional().describe("Issue management configuration"),
+  versionControl: z.object({
+    provider: z.enum(["github", "bitbucket"]).optional().describe("Version control provider (github, bitbucket)"),
+    bitbucket: z.object({
+      username: z.string().min(1, "BitBucket username cannot be empty").describe("BitBucket username"),
+      apiToken: z.string().optional().describe("BitBucket API token. SECURITY: Store in settings.local.json only, never commit to source control. Generate at: https://bitbucket.org/account/settings/app-passwords/ (Note: App passwords deprecated Sep 2025, use API tokens)"),
+      workspace: z.string().optional().describe("BitBucket workspace (optional, auto-detected from git remote if not provided)"),
+      repoSlug: z.string().optional().describe("BitBucket repository slug (optional, auto-detected from git remote if not provided)"),
+      reviewers: z.array(z.string().describe("Reviewer username")).optional().describe("List of usernames to add as PR reviewers. Usernames are resolved to Bitbucket account IDs at PR creation time.")
+    }).optional()
+  }).optional().describe("Version control provider configuration"),
   mergeBehavior: z.object({
-    mode: z.enum(["local", "github-pr", "github-draft-pr"]).optional(),
+    mode: z.enum(mergeModeValues).transform(mergeModeTransform).optional(),
     remote: z.string().optional(),
     autoCommitPush: z.boolean().optional().describe(
-      "Auto-commit and push after code review in draft PR mode. Defaults to true when mode is github-draft-pr."
+      "Auto-commit and push after code review in draft PR mode. Defaults to true when mode is draft-pr."
     ),
+    prTitlePrefix: z.boolean().optional(),
     openBrowserOnFinish: z.boolean().optional().describe(
-      "Open the PR in the default browser after finishing in github-pr or github-draft-pr mode. Use --no-browser flag to override."
+      "Open the PR in the default browser after finishing in pr or draft-pr mode. Use --no-browser flag to override."
     )
-  }).optional().describe("Merge behavior configuration: local (merge locally), github-pr (create PR), or github-draft-pr (create draft PR at start, mark ready on finish)"),
+  }).optional().describe("Merge behavior configuration: local (merge locally), pr (create PR), or draft-pr (create draft PR at start, mark ready on finish)"),
   ide: z.object({
     type: z.enum(["vscode", "cursor", "webstorm", "sublime", "intellij", "windsurf", "antigravity"]).optional().describe(
       "IDE to launch when starting a loom. Options: vscode (Visual Studio Code), cursor (Cursor AI editor), webstorm (JetBrains WebStorm), sublime (Sublime Text), intellij (JetBrains IntelliJ IDEA), windsurf (Windsurf editor), antigravity (Antigravity IDE)."
@@ -3004,7 +3120,7 @@ function redactSensitiveFields(obj) {
   if (obj === null || obj === void 0) return obj;
   if (typeof obj !== "object") return obj;
   if (Array.isArray(obj)) return obj.map(redactSensitiveFields);
-  const sensitiveKeys = ["apitoken", "token", "secret", "password"];
+  const sensitiveKeys = ["apitoken", "token", "secret", "password", "credential"];
   const result = {};
   for (const [key, value] of Object.entries(obj)) {
     const lowerKey = key.toLowerCase();
@@ -3269,6 +3385,17 @@ ${errorMessages.join("\n")}`
     var _a;
     return ((_a = settings2 == null ? void 0 : settings2.plan) == null ? void 0 : _a.reviewer) ?? "none";
   }
+  /**
+   * Get the plan command waveVerification setting with default applied
+   * Default is true (verification tasks are generated)
+   *
+   * @param settings - Pre-loaded settings object
+   * @returns Whether wave verification is enabled
+   */
+  getPlanWaveVerification(settings2) {
+    var _a;
+    return ((_a = settings2 == null ? void 0 : settings2.plan) == null ? void 0 : _a.waveVerification) !== false;
+  }
   /**
    * Get the session summary model with default applied
    * Default is defined in SummarySettingsSchema
@@ -3730,8 +3857,672 @@ var JiraWikiSanitizer = class {
   }
 };
 
+// src/lib/providers/bitbucket/BitBucketApiClient.ts
+import https2 from "https";
+var BitBucketApiClient = class {
+  constructor(config) {
+    this.baseUrl = "https://api.bitbucket.org/2.0";
+    const credentials = Buffer.from(`${config.username}:${config.apiToken}`).toString("base64");
+    this.authHeader = `Basic ${credentials}`;
+    this.workspace = config.workspace;
+    this.repoSlug = config.repoSlug;
+  }
+  /**
+   * Make an HTTP request to BitBucket API
+   */
+  async request(method, endpoint, body) {
+    const url = endpoint.startsWith("http://") || endpoint.startsWith("https://") ? new URL(endpoint) : new URL(`${this.baseUrl}${endpoint}`);
+    if ((endpoint.startsWith("http://") || endpoint.startsWith("https://")) && url.hostname !== "api.bitbucket.org") {
+      throw new Error(`Refusing to send authenticated request to unexpected host: ${url.hostname} (expected api.bitbucket.org)`);
+    }
+    getLogger().debug(`BitBucket API ${method} request`, { url: url.toString() });
+    return new Promise((resolve, reject) => {
+      const options = {
+        hostname: url.hostname,
+        port: url.port || 443,
+        path: url.pathname + url.search,
+        method,
+        headers: {
+          "Authorization": this.authHeader,
+          "Accept": "application/json",
+          "Content-Type": "application/json"
+        }
+      };
+      const req = https2.request(options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          if (!res.statusCode || res.statusCode < 200 || res.statusCode >= 300) {
+            reject(new Error(`BitBucket API error (${res.statusCode}): ${data}`));
+            return;
+          }
+          if (res.statusCode === 204 || !data) {
+            resolve({});
+            return;
+          }
+          try {
+            resolve(JSON.parse(data));
+          } catch (error) {
+            reject(new Error(`Failed to parse BitBucket API response: ${error}`));
+          }
+        });
+      });
+      req.on("error", (error) => {
+        reject(new Error(`BitBucket API request failed: ${error.message}`));
+      });
+      if (body) {
+        req.write(JSON.stringify(body));
+      }
+      req.end();
+    });
+  }
+  /**
+   * Make a GET request to BitBucket API
+   */
+  async get(endpoint) {
+    return this.request("GET", endpoint);
+  }
+  /**
+   * Make a POST request to BitBucket API
+   */
+  async post(endpoint, body) {
+    return this.request("POST", endpoint, body);
+  }
+  /**
+   * Make a PUT request to BitBucket API
+   */
+  async put(endpoint, body) {
+    return this.request("PUT", endpoint, body);
+  }
+  /**
+   * Get repository information
+   */
+  async getRepository(workspace, repoSlug) {
+    return this.get(`/repositories/${workspace}/${repoSlug}`);
+  }
+  /**
+   * Get a pull request by ID
+   */
+  async getPullRequest(workspace, repoSlug, prId) {
+    return this.get(
+      `/repositories/${workspace}/${repoSlug}/pullrequests/${prId}`
+    );
+  }
+  /**
+   * List open pull requests for a branch
+   *
+   * Note: BitBucket uses BBQL (BitBucket Query Language) for filtering.
+   * The q parameter must use the format: q=source.branch.name="branch-name"
+   * When using BBQL, we include state filter in the query to ensure it's applied.
+   * See: https://developer.atlassian.com/cloud/bitbucket/rest/intro/#filtering
+   */
+  async listPullRequests(workspace, repoSlug, sourceBranch) {
+    let endpoint = `/repositories/${workspace}/${repoSlug}/pullrequests`;
+    if (sourceBranch) {
+      const safeBranch = sourceBranch.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+      const query = `state="OPEN" AND source.branch.name="${safeBranch}"`;
+      endpoint += `?q=${encodeURIComponent(query)}`;
+    } else {
+      endpoint += `?state=OPEN`;
+    }
+    const response = await this.get(endpoint);
+    return response.values;
+  }
+  /**
+   * Create a pull request
+   */
+  async createPullRequest(workspace, repoSlug, title, description, sourceBranch, destinationBranch, reviewerAccountIds) {
+    const payload = {
+      title,
+      description,
+      source: {
+        branch: {
+          name: sourceBranch
+        }
+      },
+      destination: {
+        branch: {
+          name: destinationBranch
+        }
+      }
+    };
+    if (reviewerAccountIds && reviewerAccountIds.length > 0) {
+      payload.reviewers = reviewerAccountIds.map((id) => ({ account_id: id }));
+    }
+    return this.post(
+      `/repositories/${workspace}/${repoSlug}/pullrequests`,
+      payload
+    );
+  }
+  /**
+   * Add a comment to a pull request
+   */
+  async addPRComment(workspace, repoSlug, prId, content) {
+    return this.post(
+      `/repositories/${workspace}/${repoSlug}/pullrequests/${prId}/comments`,
+      {
+        content: {
+          raw: content
+        }
+      }
+    );
+  }
+  /**
+   * Update an existing comment on a pull request
+   */
+  async updatePRComment(workspace, repoSlug, prId, commentId, content) {
+    return this.put(
+      `/repositories/${workspace}/${repoSlug}/pullrequests/${prId}/comments/${commentId}`,
+      {
+        content: {
+          raw: content
+        }
+      }
+    );
+  }
+  /**
+   * List all comments on a pull request with pagination
+   */
+  async listPRComments(workspace, repoSlug, prId) {
+    const MAX_PAGES = 50;
+    const allComments = [];
+    let nextUrl = `/repositories/${workspace}/${repoSlug}/pullrequests/${prId}/comments`;
+    let pageCount = 0;
+    while (nextUrl) {
+      pageCount++;
+      if (pageCount > MAX_PAGES) {
+        console.error(`BitBucket listPRComments: exceeded maximum pagination limit of ${MAX_PAGES} pages, returning ${allComments.length} comments collected so far`);
+        break;
+      }
+      const response = await this.get(nextUrl);
+      allComments.push(...response.values);
+      nextUrl = response.next ?? null;
+    }
+    getLogger().debug(`Fetched ${allComments.length} PR comments from BitBucket`);
+    return allComments;
+  }
+  /**
+   * Add an inline comment to a specific file and line in a pull request
+   */
+  async addInlinePRComment(workspace, repoSlug, prId, content, filePath, line) {
+    return this.post(
+      `/repositories/${workspace}/${repoSlug}/pullrequests/${prId}/comments`,
+      {
+        content: {
+          raw: content
+        },
+        inline: {
+          to: line,
+          path: filePath
+        }
+      }
+    );
+  }
+  /**
+   * Find workspace members by usernames
+   * Returns a map of username -> account_id for resolved users
+   * Handles pagination to fetch all workspace members
+   */
+  async findUsersByUsername(workspace, usernames) {
+    const result = /* @__PURE__ */ new Map();
+    const allMembers = await this.getAllWorkspaceMembers(workspace);
+    getLogger().debug(`Resolving ${usernames.length} usernames against ${allMembers.length} workspace members`);
+    for (const username of usernames) {
+      const usernameLower = username.toLowerCase();
+      const member = allMembers.find(
+        (m) => {
+          var _a;
+          return ((_a = m.user.nickname) == null ? void 0 : _a.toLowerCase()) === usernameLower || m.user.display_name.toLowerCase() === usernameLower;
+        }
+      );
+      if (member) {
+        result.set(username, member.user.account_id);
+        getLogger().debug(`Resolved reviewer ${username} to account ID ${member.user.account_id}`);
+      } else {
+        getLogger().warn(`Could not resolve reviewer ${username} to a BitBucket account ID`);
+      }
+    }
+    return result;
+  }
+  /**
+   * Fetch all workspace members with pagination
+   */
+  async getAllWorkspaceMembers(workspace) {
+    const allMembers = [];
+    let nextUrl = `/workspaces/${workspace}/members`;
+    while (nextUrl) {
+      const response = await this.get(nextUrl);
+      allMembers.push(...response.values);
+      nextUrl = response.next ?? null;
+    }
+    getLogger().debug(`Fetched ${allMembers.length} workspace members from BitBucket`);
+    return allMembers;
+  }
+  /**
+   * Get the currently authenticated user
+   */
+  async getCurrentUser() {
+    return this.get("/user");
+  }
+  /**
+   * Test connection to BitBucket API
+   */
+  async testConnection() {
+    try {
+      await this.getCurrentUser();
+      return true;
+    } catch (error) {
+      getLogger().error("BitBucket connection test failed", { error });
+      return false;
+    }
+  }
+  /**
+   * Get configured workspace
+   */
+  getWorkspace() {
+    return this.workspace;
+  }
+  /**
+   * Get configured repository slug
+   */
+  getRepoSlug() {
+    return this.repoSlug;
+  }
+};
+
+// src/utils/remote.ts
+import { execa as execa3 } from "execa";
+async function parseGitRemotes(cwd) {
+  const result = await execa3("git", ["remote", "-v"], {
+    cwd: cwd ?? process.cwd(),
+    encoding: "utf8"
+  });
+  const lines = result.stdout.trim().split("\n");
+  const remoteMap = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const match = line.match(/^(\S+)\s+(\S+)\s+\((fetch|push)\)/);
+    if (!match) continue;
+    const name = match[1];
+    const url = match[2];
+    if (!name || !url) continue;
+    if (remoteMap.has(name)) continue;
+    const ownerRepo = extractOwnerRepoFromUrl(url);
+    if (!ownerRepo) continue;
+    remoteMap.set(name, {
+      name,
+      url,
+      owner: ownerRepo.owner,
+      repo: ownerRepo.repo
+    });
+  }
+  return Array.from(remoteMap.values());
+}
+function extractOwnerRepoFromUrl(url) {
+  const cleanUrl = url.replace(/\.git$/, "");
+  const githubHttpsMatch = cleanUrl.match(/https?:\/\/github\.com\/([^/]+)\/([^/]+)/);
+  if ((githubHttpsMatch == null ? void 0 : githubHttpsMatch[1]) && (githubHttpsMatch == null ? void 0 : githubHttpsMatch[2])) {
+    return { owner: githubHttpsMatch[1], repo: githubHttpsMatch[2] };
+  }
+  const githubSshMatch = cleanUrl.match(/git@github\.com:([^/]+)\/(.+)/);
+  if ((githubSshMatch == null ? void 0 : githubSshMatch[1]) && (githubSshMatch == null ? void 0 : githubSshMatch[2])) {
+    return { owner: githubSshMatch[1], repo: githubSshMatch[2] };
+  }
+  const bitbucketHttpsMatch = cleanUrl.match(/https?:\/\/bitbucket\.org\/([^/]+)\/([^/]+)/);
+  if ((bitbucketHttpsMatch == null ? void 0 : bitbucketHttpsMatch[1]) && (bitbucketHttpsMatch == null ? void 0 : bitbucketHttpsMatch[2])) {
+    return { owner: bitbucketHttpsMatch[1], repo: bitbucketHttpsMatch[2] };
+  }
+  const bitbucketSshMatch = cleanUrl.match(/git@bitbucket\.org:([^/]+)\/(.+)/);
+  if ((bitbucketSshMatch == null ? void 0 : bitbucketSshMatch[1]) && (bitbucketSshMatch == null ? void 0 : bitbucketSshMatch[2])) {
+    return { owner: bitbucketSshMatch[1], repo: bitbucketSshMatch[2] };
+  }
+  return null;
+}
+
+// src/lib/providers/bitbucket/BitBucketVCSProvider.ts
+var BitBucketVCSProvider = class _BitBucketVCSProvider {
+  constructor(config) {
+    this.providerName = "bitbucket";
+    this.supportsForks = true;
+    this.supportsDraftPRs = false;
+    this.client = new BitBucketApiClient(config);
+    if (config.reviewers) {
+      this.reviewerUsernames = config.reviewers;
+    }
+  }
+  /**
+   * Create a BitBucketVCSProvider from IloomSettings
+   * Extracts and validates BitBucket config from settings
+   */
+  static fromSettings(settings2) {
+    var _a;
+    const bbSettings = (_a = settings2.versionControl) == null ? void 0 : _a.bitbucket;
+    if (!(bbSettings == null ? void 0 : bbSettings.username)) {
+      throw new Error("BitBucket username is required. Configure versionControl.bitbucket.username in .iloom/settings.json");
+    }
+    if (!(bbSettings == null ? void 0 : bbSettings.apiToken)) {
+      throw new Error("BitBucket API token is required. Configure versionControl.bitbucket.apiToken in .iloom/settings.local.json");
+    }
+    const config = {
+      username: bbSettings.username,
+      apiToken: bbSettings.apiToken
+    };
+    if (bbSettings.workspace) {
+      config.workspace = bbSettings.workspace;
+    }
+    if (bbSettings.repoSlug) {
+      config.repoSlug = bbSettings.repoSlug;
+    }
+    if (bbSettings.reviewers) {
+      config.reviewers = bbSettings.reviewers;
+    }
+    return new _BitBucketVCSProvider(config);
+  }
+  /**
+   * Check if a PR already exists for the given branch
+   */
+  async checkForExistingPR(branchName, cwd) {
+    try {
+      const { workspace, repoSlug } = await this.getWorkspaceAndRepo(cwd);
+      const prs = await this.client.listPullRequests(workspace, repoSlug, branchName);
+      if (prs.length > 0 && prs[0]) {
+        const pr = prs[0];
+        return {
+          number: pr.id,
+          url: pr.links.html.href
+        };
+      }
+      return null;
+    } catch (error) {
+      if (error instanceof Error) {
+        const statusMatch = error.message.match(/BitBucket API error \((\d+)\)/);
+        if (statusMatch == null ? void 0 : statusMatch[1]) {
+          const statusCode = parseInt(statusMatch[1], 10);
+          if (statusCode === 401 || statusCode === 403) {
+            throw error;
+          }
+        }
+      }
+      getLogger().debug("Error checking for existing PR", { error });
+      return null;
+    }
+  }
+  /**
+   * Create a pull request
+   */
+  async createPR(branchName, title, body, baseBranch, cwd) {
+    var _a, _b;
+    const { workspace, repoSlug } = await this.getWorkspaceAndRepo(cwd);
+    getLogger().info(`Creating BitBucket PR in ${workspace}/${repoSlug}`);
+    getLogger().debug("PR details", { branchName, title, baseBranch });
+    let reviewerIds;
+    if (this.reviewerUsernames && this.reviewerUsernames.length > 0) {
+      reviewerIds = await this.resolveReviewerUsernames(workspace, this.reviewerUsernames);
+      if (reviewerIds.length > 0) {
+        const currentUser = await this.client.getCurrentUser();
+        const originalCount = reviewerIds.length;
+        reviewerIds = reviewerIds.filter((id) => id !== currentUser.account_id);
+        if (reviewerIds.length < originalCount) {
+          getLogger().debug(
+            `Removed current user (${currentUser.display_name}) from reviewers list - PR author cannot be a reviewer`
+          );
+        }
+      }
+    }
+    const pr = await this.client.createPullRequest(
+      workspace,
+      repoSlug,
+      title,
+      body,
+      branchName,
+      baseBranch,
+      reviewerIds
+    );
+    if (!(pr == null ? void 0 : pr.id) || !((_b = (_a = pr == null ? void 0 : pr.links) == null ? void 0 : _a.html) == null ? void 0 : _b.href)) {
+      getLogger().error("Invalid BitBucket API response", { pr });
+      throw new Error(
+        `BitBucket API returned invalid PR response. Expected PR with id and links.html.href, got: ${JSON.stringify(pr)}`
+      );
+    }
+    getLogger().info(`BitBucket PR #${pr.id} created successfully`);
+    return { url: pr.links.html.href, number: pr.id, wasExisting: false };
+  }
+  /**
+   * Fetch PR details
+   */
+  async fetchPR(prNumber, cwd) {
+    const { workspace, repoSlug } = await this.getWorkspaceAndRepo(cwd);
+    const bbPR = await this.client.getPullRequest(workspace, repoSlug, prNumber);
+    return this.mapBitBucketPRToPullRequest(bbPR);
+  }
+  /**
+   * Get PR URL
+   */
+  async getPRUrl(prNumber, cwd) {
+    const { workspace, repoSlug } = await this.getWorkspaceAndRepo(cwd);
+    const bbPR = await this.client.getPullRequest(workspace, repoSlug, prNumber);
+    return bbPR.links.html.href;
+  }
+  /**
+   * Create a comment on a PR
+   */
+  async createPRComment(prNumber, body, cwd) {
+    const { workspace, repoSlug } = await this.getWorkspaceAndRepo(cwd);
+    getLogger().debug("Creating BitBucket PR comment", { workspace, repoSlug, prNumber });
+    const comment = await this.client.addPRComment(workspace, repoSlug, prNumber, body);
+    return { id: String(comment.id), url: comment.links.html.href };
+  }
+  /**
+   * Update an existing comment on a PR
+   */
+  async updatePRComment(prNumber, commentId, body, cwd) {
+    const { workspace, repoSlug } = await this.getWorkspaceAndRepo(cwd);
+    getLogger().debug("Updating BitBucket PR comment", { workspace, repoSlug, prNumber, commentId });
+    const numericCommentId = parseInt(commentId, 10);
+    if (isNaN(numericCommentId)) {
+      throw new Error(`Invalid comment ID "${commentId}": expected a numeric value`);
+    }
+    const comment = await this.client.updatePRComment(workspace, repoSlug, prNumber, numericCommentId, body);
+    return { id: String(comment.id), url: comment.links.html.href };
+  }
+  /**
+   * Get inline review comments on a PR
+   * Fetches all comments and filters for those with inline metadata
+   */
+  async getReviewComments(prNumber, cwd) {
+    const { workspace, repoSlug } = await this.getWorkspaceAndRepo(cwd);
+    getLogger().debug("Fetching BitBucket PR review comments", { workspace, repoSlug, prNumber });
+    const allComments = await this.client.listPRComments(workspace, repoSlug, prNumber);
+    const inlineComments = [];
+    for (const c of allComments) {
+      if (c.inline == null) continue;
+      inlineComments.push({
+        id: String(c.id),
+        body: c.content.raw,
+        path: c.inline.path,
+        line: c.inline.to ?? c.inline.from ?? null,
+        side: null,
+        // BitBucket doesn't have a "side" concept like GitHub
+        author: c.user ? { id: c.user.uuid, displayName: c.user.display_name } : null,
+        createdAt: c.created_on ?? "",
+        updatedAt: c.updated_on ?? null,
+        inReplyToId: null
+        // BitBucket uses nested comments, not reply chains
+      });
+    }
+    return inlineComments;
+  }
+  /**
+   * Create an inline review comment on a specific file and line in a PR
+   */
+  async createReviewComment(prNumber, path3, line, body, cwd) {
+    const { workspace, repoSlug } = await this.getWorkspaceAndRepo(cwd);
+    getLogger().debug("Creating BitBucket inline PR comment", { workspace, repoSlug, prNumber, path: path3, line });
+    const comment = await this.client.addInlinePRComment(workspace, repoSlug, prNumber, body, path3, line);
+    return { id: String(comment.id), url: comment.links.html.href };
+  }
+  /**
+   * List open pull requests for the repository
+   * Uses getWorkspaceAndRepo for auto-detection from git remotes
+   */
+  async listPullRequests(cwd) {
+    const { workspace, repoSlug } = await this.getWorkspaceAndRepo(cwd);
+    return this.client.listPullRequests(workspace, repoSlug);
+  }
+  /**
+   * Detect repository from git remote
+   */
+  async detectRepository(cwd) {
+    try {
+      const remotes = await parseGitRemotes(cwd);
+      const bbRemote = remotes.find(
+        (r) => r.url.includes("bitbucket.org")
+      );
+      if (!bbRemote) {
+        return null;
+      }
+      return {
+        owner: bbRemote.owner,
+        // workspace
+        repo: bbRemote.repo
+      };
+    } catch (error) {
+      getLogger().error("Failed to detect BitBucket repository", { error });
+      return null;
+    }
+  }
+  /**
+   * Get target remote for PR operations
+   */
+  async getTargetRemote(_cwd) {
+    return "origin";
+  }
+  /**
+   * Get workspace and repository slug from config or git remote
+   */
+  async getWorkspaceAndRepo(cwd) {
+    let workspace = this.client.getWorkspace();
+    let repoSlug = this.client.getRepoSlug();
+    if (!workspace || !repoSlug) {
+      const detected = await this.detectRepository(cwd);
+      if (!detected) {
+        throw new Error(
+          "Could not determine BitBucket workspace/repository. Either configure them in settings or ensure git remote points to bitbucket.org"
+        );
+      }
+      workspace = workspace ?? detected.owner;
+      repoSlug = repoSlug ?? detected.repo;
+    }
+    return { workspace, repoSlug };
+  }
+  /**
+   * Resolve reviewer usernames to BitBucket account IDs
+   * Warns for any usernames that cannot be resolved but continues with partial list
+   */
+  async resolveReviewerUsernames(workspace, usernames) {
+    getLogger().debug(`Resolving ${usernames.length} reviewer username(s) to BitBucket account IDs`);
+    const usernameToAccountId = await this.client.findUsersByUsername(workspace, usernames);
+    const resolvedIds = [];
+    const unresolvedUsernames = [];
+    for (const username of usernames) {
+      const accountId = usernameToAccountId.get(username);
+      if (accountId) {
+        resolvedIds.push(accountId);
+      } else {
+        unresolvedUsernames.push(username);
+      }
+    }
+    if (unresolvedUsernames.length > 0) {
+      getLogger().warn(
+        `Could not resolve ${unresolvedUsernames.length} reviewer username(s) to BitBucket account IDs: ${unresolvedUsernames.join(", ")}. These reviewers will not be added to the PR.`
+      );
+    }
+    if (resolvedIds.length > 0) {
+      getLogger().info(`Resolved ${resolvedIds.length} reviewer(s) for PR`);
+    }
+    return resolvedIds;
+  }
+  /**
+   * Map BitBucket PR to generic PullRequest type
+   */
+  mapBitBucketPRToPullRequest(bbPR) {
+    let state;
+    if (bbPR.state === "OPEN") {
+      state = "open";
+    } else if (bbPR.state === "MERGED") {
+      state = "merged";
+    } else {
+      state = "closed";
+    }
+    return {
+      number: bbPR.id,
+      title: bbPR.title,
+      body: bbPR.description,
+      state,
+      branch: bbPR.source.branch.name,
+      baseBranch: bbPR.destination.branch.name,
+      url: bbPR.links.html.href,
+      isDraft: false
+      // BitBucket doesn't have draft PRs
+    };
+  }
+};
+
+// src/lib/VCSProviderFactory.ts
+var VCSProviderFactory = class {
+  /**
+   * Create a VersionControlProvider instance based on settings configuration
+   * 
+   * @param settings - iloom settings containing versionControl.provider
+   * @returns VersionControlProvider instance configured for the specified provider
+   * @throws Error if provider type is not supported or required config is missing
+   */
+  static create(settings2) {
+    var _a;
+    const provider = (_a = settings2.versionControl) == null ? void 0 : _a.provider;
+    if (!provider) {
+      getLogger().debug("VCSProviderFactory: No versionControl.provider configured, using legacy PRManager");
+      return null;
+    }
+    getLogger().debug(`VCSProviderFactory: Creating VCS provider for "${provider}"`);
+    switch (provider) {
+      case "github":
+        getLogger().debug("VCSProviderFactory: GitHub uses legacy PRManager, returning null");
+        return null;
+      case "bitbucket": {
+        getLogger().debug(`VCSProviderFactory: Creating BitBucketVCSProvider from settings`);
+        return BitBucketVCSProvider.fromSettings(settings2);
+      }
+      default:
+        throw new Error(`Unsupported VCS provider: ${provider}`);
+    }
+  }
+  /**
+   * Check if a VCS provider is configured
+   * 
+   * @param settings - iloom settings
+   * @returns true if versionControl provider is configured
+   */
+  static isConfigured(settings2) {
+    var _a, _b;
+    return ((_a = settings2.versionControl) == null ? void 0 : _a.provider) !== void 0 && ((_b = settings2.versionControl) == null ? void 0 : _b.provider) !== "github";
+  }
+  /**
+   * Get the configured provider name from settings
+   * 
+   * @param settings - iloom settings
+   * @returns Provider type string or undefined if not configured
+   */
+  static getProviderName(settings2) {
+    var _a;
+    return (_a = settings2.versionControl) == null ? void 0 : _a.provider;
+  }
+};
+
 // src/mcp/issue-management-server.ts
 var settings;
+var vcsProvider = null;
 function validateEnvironment() {
   const provider = process.env.ISSUE_PROVIDER;
   if (!provider) {
@@ -3849,7 +4640,7 @@ server.registerTool(
   "get_pr",
   {
     title: "Get Pull Request",
-    description: "Fetch pull request details including title, body, comments, files, commits, and branch information. PRs only exist on GitHub, so this tool always uses GitHub regardless of configured issue tracker. Author fields have normalized core fields: { id, displayName } plus provider-specific fields.",
+    description: "Fetch pull request details including title, body, comments, files, commits, and branch information. Uses the configured VCS provider (GitHub or BitBucket). Falls back to GitHub when no VCS provider is configured. Author fields have normalized core fields: { id, displayName } plus provider-specific fields.",
     inputSchema: {
       number: z2.string().describe("The PR number"),
       includeComments: z2.boolean().optional().describe("Whether to include comments (default: true)"),
@@ -3900,6 +4691,34 @@ server.registerTool(
   async ({ number, includeComments, repo }) => {
     console.error(`Fetching PR ${number}${repo ? ` from ${repo}` : ""}`);
     try {
+      if (vcsProvider) {
+        if (repo) {
+          console.error(`VCS provider path does not support 'repo' override parameter, using configured repository`);
+        }
+        const pr = await vcsProvider.fetchPR(parseInt(number, 10));
+        const result2 = {
+          id: String(pr.number),
+          number: pr.number,
+          title: pr.title,
+          body: pr.body,
+          state: pr.state.toUpperCase(),
+          url: pr.url,
+          headRefName: pr.branch,
+          baseRefName: pr.baseBranch,
+          author: null,
+          isDraft: pr.isDraft
+        };
+        console.error(`PR fetched successfully: #${result2.number} - ${result2.title}`);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result2)
+            }
+          ],
+          structuredContent: result2
+        };
+      }
       const provider = new GitHubIssueManagementProvider();
       const result = await provider.getPR({ number, includeComments, repo });
       console.error(`PR fetched successfully: #${result.number} - ${result.title}`);
@@ -3923,7 +4742,7 @@ server.registerTool(
   "get_review_comments",
   {
     title: "Get PR Review Comments",
-    description: "Fetch inline code review comments on a pull request (comments on specific files and lines). Returns comments with file path, line number, diff side, author, and reply threading. Optionally filter by review ID. PRs only exist on GitHub, so this tool always uses GitHub.",
+    description: "Fetch inline code review comments on a pull request (comments on specific files and lines). Returns comments with file path, line number, diff side, author, and reply threading. Uses the configured VCS provider when available, falls back to GitHub.",
     inputSchema: {
       number: z2.string().describe("The PR number"),
       reviewId: z2.string().optional().describe("Optional review ID to filter comments by a specific review"),
@@ -3951,6 +4770,30 @@ server.registerTool(
   async ({ number, reviewId, repo }) => {
     console.error(`Fetching review comments for PR ${number}${reviewId ? ` (review ${reviewId})` : ""}${repo ? ` from ${repo}` : ""}`);
     try {
+      if (vcsProvider == null ? void 0 : vcsProvider.getReviewComments) {
+        if (repo) {
+          console.error(`VCS provider path does not support 'repo' override parameter, using configured repository`);
+        }
+        if (reviewId) {
+          console.error(`VCS provider path does not support 'reviewId' filter, returning all inline comments`);
+        }
+        const reviewComments = await vcsProvider.getReviewComments(parseInt(number, 10));
+        const comments2 = reviewComments.map((c) => ({
+          ...c,
+          pullRequestReviewId: null
+        }));
+        console.error(`Review comments fetched successfully: ${comments2.length} comments`);
+        const result2 = { comments: comments2 };
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result2)
+            }
+          ],
+          structuredContent: result2
+        };
+      }
       const provider = new GitHubIssueManagementProvider();
       const comments = await provider.getReviewComments({ number, reviewId, repo });
       console.error(`Review comments fetched successfully: ${comments.length} comments`);
@@ -4039,6 +4882,22 @@ server.registerTool(
     console.error(`Creating ${type} comment on ${number}`);
     try {
       const sanitizedBody = JiraWikiSanitizer.sanitize(body);
+      if (type === "pr" && vcsProvider) {
+        const vcsResult = await vcsProvider.createPRComment(parseInt(number, 10), sanitizedBody);
+        console.error(
+          `Comment created successfully: ${vcsResult.id} at ${vcsResult.url}`
+        );
+        const result2 = { id: vcsResult.id, url: vcsResult.url, created_at: (/* @__PURE__ */ new Date()).toISOString() };
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result2)
+            }
+          ],
+          structuredContent: result2
+        };
+      }
       const providerType = type === "pr" ? "github" : process.env.ISSUE_PROVIDER;
       const provider = IssueManagementProviderFactory.create(providerType, settings);
       const result = await provider.createComment({ number, body: sanitizedBody, type });
@@ -4083,6 +4942,22 @@ server.registerTool(
     console.error(`Updating comment ${commentId} on ${type === "pr" ? "PR" : "issue"} ${number}`);
     try {
       const sanitizedBody = JiraWikiSanitizer.sanitize(body);
+      if (type === "pr" && (vcsProvider == null ? void 0 : vcsProvider.updatePRComment)) {
+        const vcsResult = await vcsProvider.updatePRComment(parseInt(number, 10), commentId, sanitizedBody);
+        console.error(
+          `Comment updated successfully: ${vcsResult.id} at ${vcsResult.url}`
+        );
+        const result2 = { id: vcsResult.id, url: vcsResult.url, updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result2)
+            }
+          ],
+          structuredContent: result2
+        };
+      }
       const providerType = type === "pr" ? "github" : process.env.ISSUE_PROVIDER;
       const provider = IssueManagementProviderFactory.create(providerType, settings);
       const result = await provider.updateComment({ commentId, number, body: sanitizedBody });
@@ -4532,6 +5407,19 @@ async function main() {
   const settingsManager = new SettingsManager();
   settings = await settingsManager.loadSettings();
   console.error("Settings loaded");
+  try {
+    vcsProvider = VCSProviderFactory.create(settings);
+    if (vcsProvider) {
+      console.error(`VCS provider initialized: ${vcsProvider.providerName}`);
+    }
+  } catch (error) {
+    if (error instanceof Error && (error.message.includes("is required") || error.message.includes("Unsupported VCS provider"))) {
+      console.error(`Failed to initialize VCS provider (falling back to GitHub): ${error.message}`);
+      vcsProvider = null;
+    } else {
+      throw error;
+    }
+  }
   const provider = validateEnvironment();
   console.error("Environment validated");
   console.error(`Issue management provider: ${provider}`);