mpd-llm-cli 0.1.25 → 0.1.31

package/bundle/gemini.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { createRequire } from 'module'; const require = createRequire(import.meta.url); globalThis.__filename = require('url').fileURLToPath(import.meta.url); globalThis.__dirname = require('path').dirname(globalThis.__filename);
+import { createRequire } from 'module'; const require = createRequire(import.meta.url); globalThis.require = require; globalThis.__filename = require('url').fileURLToPath(import.meta.url); globalThis.__dirname = require('path').dirname(globalThis.__filename);
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -70110,10 +70110,10 @@ async function cacheCredentials(credentials) {
   await fs7.writeFile(filePath, credString);
 }
 function getCachedCredentialPath() {
-  return path2.join(os3.homedir(), GEMINI_DIR, CREDENTIAL_FILENAME);
+  return path2.join(os3.homedir(), MPDAI_DIR, CREDENTIAL_FILENAME);
 }
 function getGoogleAccountIdCachePath() {
-  return path2.join(os3.homedir(), GEMINI_DIR, GOOGLE_ACCOUNT_ID_FILENAME);
+  return path2.join(os3.homedir(), MPDAI_DIR, GOOGLE_ACCOUNT_ID_FILENAME);
 }
 async function cacheGoogleAccountId(googleAccountId) {
   const filePath = getGoogleAccountIdCachePath();
@@ -70168,7 +70168,7 @@ async function getRawGoogleAccountId(client) {
     return null;
   }
 }
-var import_google_auth_library2, OAUTH_CLIENT_ID, OAUTH_CLIENT_SECRET, OAUTH_SCOPE, HTTP_REDIRECT, SIGN_IN_SUCCESS_URL, SIGN_IN_FAILURE_URL, GEMINI_DIR, CREDENTIAL_FILENAME, GOOGLE_ACCOUNT_ID_FILENAME;
+var import_google_auth_library2, OAUTH_CLIENT_ID, OAUTH_CLIENT_SECRET, OAUTH_SCOPE, HTTP_REDIRECT, SIGN_IN_SUCCESS_URL, SIGN_IN_FAILURE_URL, MPDAI_DIR, CREDENTIAL_FILENAME, GOOGLE_ACCOUNT_ID_FILENAME;
 var init_oauth2 = __esm({
   "packages/core/dist/src/code_assist/oauth2.js"() {
     "use strict";
@@ -70186,7 +70186,7 @@ var init_oauth2 = __esm({
     HTTP_REDIRECT = 301;
     SIGN_IN_SUCCESS_URL = "https://developers.google.com/gemini-code-assist/auth_success_gemini";
     SIGN_IN_FAILURE_URL = "https://developers.google.com/gemini-code-assist/auth_failure_gemini";
-    GEMINI_DIR = ".gemini";
+    MPDAI_DIR = ".mpdai";
     CREDENTIAL_FILENAME = "oauth_creds.json";
     GOOGLE_ACCOUNT_ID_FILENAME = "google_account_id";
   }
@@ -70520,7 +70520,7 @@ var init_setup = __esm({
     init_server();
     ProjectIdRequiredError = class extends Error {
       constructor() {
-        super("This account requires setting the GOOGLE_CLOUD_PROJECT env var. See https://goo.gle/gemini-cli-auth-docs#workspace-gca");
+        super("This account requires setting the GOOGLE_CLOUD_PROJECT env var. See https://git.rakuten-it.com/projects/MPD-AI/repos/mpd-llm-cli/browse/docs/cli/authentication.md");
       }
     };
   }
@@ -78281,7 +78281,7 @@ async function createContentGeneratorConfig(model, authType) {
   return contentGeneratorConfig;
 }
 async function createContentGenerator(config2, sessionId2) {
-  const version3 = "0.1.25";
+  const version3 = "0.1.31";
   const httpOptions = {
     headers: {
       "User-Agent": `GeminiCLI/${version3} (${process.platform}; ${process.arch})`
@@ -92912,6 +92912,12 @@ function _sanitizeParameters(schema, visited) {
     return;
   }
   visited.add(schema);
+  if ("$schema" in schema) {
+    delete schema.$schema;
+  }
+  if ("additionalProperties" in schema) {
+    delete schema.additionalProperties;
+  }
   if (schema.anyOf) {
     schema.default = void 0;
     for (const item of schema.anyOf) {
@@ -99694,13 +99700,13 @@ function getProjectHash(projectRoot) {
 }
 function getProjectTempDir(projectRoot) {
   const hash = getProjectHash(projectRoot);
-  return path4.join(os4.homedir(), GEMINI_DIR2, TMP_DIR_NAME, hash);
+  return path4.join(os4.homedir(), MPDAI_DIR2, TMP_DIR_NAME, hash);
 }
-var GEMINI_DIR2, TMP_DIR_NAME;
+var MPDAI_DIR2, TMP_DIR_NAME;
 var init_paths = __esm({
   "packages/core/dist/src/utils/paths.js"() {
     "use strict";
-    GEMINI_DIR2 = ".gemini";
+    MPDAI_DIR2 = ".mpdai";
     TMP_DIR_NAME = "tmp";
   }
 });
@@ -110591,7 +110597,7 @@ var init_read_file = __esm({
         const fileService = this.config.getFileService();
         if (fileService.shouldGeminiIgnoreFile(params.absolute_path)) {
           const relativePath = makeRelative(params.absolute_path, this.rootDirectory);
-          return `File path '${shortenPath(relativePath)}' is ignored by .geminiignore pattern(s).`;
+          return `File path '${shortenPath(relativePath)}' is ignored by .mpdaiignore pattern(s).`;
         }
         return null;
       }
@@ -119027,7 +119033,7 @@ function getAllGeminiMdFilenames() {
   return [currentGeminiMdFilename];
 }
 function getGlobalMemoryFilePath() {
-  return path13.join(homedir2(), GEMINI_CONFIG_DIR, getCurrentGeminiMdFilename());
+  return path13.join(homedir2(), MPDAI_CONFIG_DIR, getCurrentGeminiMdFilename());
 }
 function ensureNewlineSeparation(currentContent) {
   if (currentContent.length === 0)
@@ -119038,7 +119044,7 @@ function ensureNewlineSeparation(currentContent) {
     return "\n";
   return "\n\n";
 }
-var memoryToolSchemaData, memoryToolDescription, GEMINI_CONFIG_DIR, DEFAULT_CONTEXT_FILENAME, MEMORY_SECTION_HEADER, currentGeminiMdFilename, MemoryTool;
+var memoryToolSchemaData, memoryToolDescription, MPDAI_CONFIG_DIR, DEFAULT_CONTEXT_FILENAME, MEMORY_SECTION_HEADER, currentGeminiMdFilename, MemoryTool;
 var init_memoryTool = __esm({
   "packages/core/dist/src/tools/memoryTool.js"() {
     "use strict";
@@ -119076,7 +119082,7 @@ Do NOT use this tool:
 
 - \`fact\` (string, required): The specific fact or piece of information to remember. This should be a clear, self-contained statement. For example, if the user says "My favorite color is blue", the fact would be "My favorite color is blue".
 `;
-    GEMINI_CONFIG_DIR = ".gemini";
+    MPDAI_CONFIG_DIR = ".mpdai";
     DEFAULT_CONTEXT_FILENAME = "MEMORY.md";
     MEMORY_SECTION_HEADER = "## Memory Added Memories";
     currentGeminiMdFilename = DEFAULT_CONTEXT_FILENAME;
@@ -119303,7 +119309,7 @@ Use this tool when the user's query implies needing the content of several files
         if (this.geminiIgnorePatterns.length > 0) {
           const geminiPatternsInEffect = this.geminiIgnorePatterns.filter((p) => finalExclusionPatternsForDescription.includes(p)).length;
           if (geminiPatternsInEffect > 0) {
-            excludeDesc += ` (includes ${geminiPatternsInEffect} from .geminiignore)`;
+            excludeDesc += ` (includes ${geminiPatternsInEffect} from .mpdaiignore)`;
           }
         }
         return `Will attempt to read and concatenate files ${pathDesc}. ${excludeDesc}. File encoding: ${DEFAULT_ENCODING}. Separator: "${DEFAULT_OUTPUT_SEPARATOR_FORMAT.replace("{filePath}", "path/to/file.ext")}".`;
@@ -121479,8 +121485,8 @@ function many(p) {
 function many1(p) {
   return ab(p, many(p), (head, tail) => [head, ...tail]);
 }
-function ab(pa, pb, join24) {
-  return (data, i) => mapOuter(pa(data, i), (ma) => mapInner(pb(data, ma.position), (vb, j) => join24(ma.value, vb, data, i, j)));
+function ab(pa, pb, join25) {
+  return (data, i) => mapOuter(pa(data, i), (ma) => mapInner(pb(data, ma.position), (vb, j) => join25(ma.value, vb, data, i, j)));
 }
 function left(pa, pb) {
   return ab(pa, pb, (va) => va);
@@ -121488,8 +121494,8 @@ function left(pa, pb) {
 function right(pa, pb) {
   return ab(pa, pb, (va, vb) => vb);
 }
-function abc(pa, pb, pc, join24) {
-  return (data, i) => mapOuter(pa(data, i), (ma) => mapOuter(pb(data, ma.position), (mb) => mapInner(pc(data, mb.position), (vc, j) => join24(ma.value, mb.value, vc, data, i, j))));
+function abc(pa, pb, pc, join25) {
+  return (data, i) => mapOuter(pa(data, i), (ma) => mapOuter(pb(data, ma.position), (mb) => mapInner(pc(data, mb.position), (vc, j) => join25(ma.value, mb.value, vc, data, i, j))));
 }
 function middle(pa, pb, pc) {
   return abc(pa, pb, pc, (ra, rb) => rb);
@@ -126454,6 +126460,991 @@ ${modifiedResponseText}`,
   }
 });
 
+// packages/core/dist/src/tools/confluence-get-page.js
+var CONFLUENCE_FETCH_TIMEOUT_MS, CONFLUENCE_URL, ConfluenceGetPageTool;
+var init_confluence_get_page = __esm({
+  "packages/core/dist/src/tools/confluence-get-page.js"() {
+    "use strict";
+    init_schemaValidator();
+    init_tools();
+    init_node();
+    init_errors();
+    CONFLUENCE_FETCH_TIMEOUT_MS = 3e4;
+    CONFLUENCE_URL = "https://confluence.rakuten-it.com/confluence";
+    ConfluenceGetPageTool = class _ConfluenceGetPageTool extends BaseTool {
+      config;
+      static Name = "confluence_get_page";
+      constructor(config2) {
+        super(_ConfluenceGetPageTool.Name, "ConfluenceGetPage", "Retrieves content from a Confluence page by its ID. Uses Personal Access Token from keys.json for authentication and can convert HTML content to markdown.", {
+          properties: {
+            page_id: {
+              description: "The ID of the Confluence page to retrieve",
+              type: Type.STRING
+            },
+            convert_to_markdown: {
+              description: "Whether to convert HTML content to markdown format (default: true)",
+              type: Type.STRING
+            }
+          },
+          required: ["page_id"],
+          type: Type.OBJECT
+        });
+        this.config = config2;
+      }
+      validateParams(params) {
+        const errors = SchemaValidator.validate(this.schema.parameters, params);
+        if (errors) {
+          return errors;
+        }
+        if (!params.page_id || params.page_id.trim() === "") {
+          return "The 'page_id' parameter cannot be empty.";
+        }
+        return null;
+      }
+      getDescription(params) {
+        return `Retrieving Confluence page ${params.page_id} from ${CONFLUENCE_URL}`;
+      }
+      /**
+       * Process HTML content to handle user mentions and page links
+       */
+      processHtmlContent(html, spaceKey, baseUrl) {
+        let processed = html;
+        processed = processed.replace(/<ac:link>[\s\S]*?<ri:user[^>]+ri:username="([^"]+)"\s*\/>[\s\S]*?<\/ac:link>/g, "@$1");
+        processed = processed.replace(/<ac:link[^>]*>[\s\S]*?<ri:page[^>]+ri:content-title="([^"]*)"\s*ri:space-key="([^"]*)"\s*\/>[\s\S]*?<\/ac:link>/g, (match2, title) => {
+          return title || "Page Link";
+        });
+        processed = processed.replace(/<\/?(span|div|p)[^>]*>/g, "\n");
+        processed = processed.replace(/<strong>([^<]*)<\/strong>/g, "**$1**");
+        processed = processed.replace(/<b>([^<]*)<\/b>/g, "**$1**");
+        processed = processed.replace(/<em>([^<]*)<\/em>/g, "*$1*");
+        processed = processed.replace(/<i>([^<]*)<\/i>/g, "*$1*");
+        for (let i = 1; i <= 6; i++) {
+          const tag = `h${i}`;
+          const prefix = "#".repeat(i);
+          processed = processed.replace(new RegExp(`<${tag}>([^<]*)</${tag}>`, "g"), `${prefix} $1`);
+        }
+        processed = processed.replace(/<li>([^<]*)<\/li>/g, "- $1\n");
+        processed = processed.replace(/<ul[^>]*>/g, "\n");
+        processed = processed.replace(/<\/ul>/g, "\n");
+        processed = processed.replace(/<ol[^>]*>/g, "\n");
+        processed = processed.replace(/<\/ol>/g, "\n");
+        processed = processed.replace(/<a[^>]+href="([^"]*)"[^>]*>([^<]*)<\/a>/g, "[$2]($1)");
+        processed = processed.replace(/<[^>]+>/g, "");
+        processed = processed.replace(/\n{3,}/g, "\n\n");
+        return processed.trim();
+      }
+      async execute(params, signal) {
+        const validationError = this.validateParams(params);
+        if (validationError) {
+          return {
+            llmContent: `Error: Invalid parameters provided. Reason: ${validationError}`,
+            returnDisplay: validationError
+          };
+        }
+        const { page_id, convert_to_markdown = true } = params;
+        const personal_access_token = this.config.getConfluenceToken();
+        if (!personal_access_token) {
+          return {
+            llmContent: "Error: Confluence Personal Access Token not found in keys.json. Please configure it first.",
+            returnDisplay: "Confluence token not configured"
+          };
+        }
+        try {
+          const isCloud = CONFLUENCE_URL.includes(".atlassian.net");
+          const apiUrl = `${CONFLUENCE_URL.replace(/\/$/, "")}/rest/api/content/${page_id}`;
+          const paramsObj = new URLSearchParams({
+            expand: "body.storage,version,space,children.attachment,ancestors"
+          });
+          const fullUrl = `${apiUrl}?${paramsObj.toString()}`;
+          const headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${personal_access_token}`
+          };
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), CONFLUENCE_FETCH_TIMEOUT_MS);
+          let response;
+          try {
+            response = await fetch(fullUrl, {
+              method: "GET",
+              headers,
+              signal: signal || controller.signal
+            });
+          } finally {
+            clearTimeout(timeoutId);
+          }
+          if (response.status === 401) {
+            return {
+              llmContent: "Error: Authentication failed (401). Personal Access Token may be invalid or expired.",
+              returnDisplay: "Authentication failed (401)"
+            };
+          }
+          if (response.status === 403) {
+            return {
+              llmContent: "Error: Access denied (403). Token may not have sufficient permissions.",
+              returnDisplay: "Access denied (403)"
+            };
+          }
+          if (response.status === 404) {
+            return {
+              llmContent: `Error: Page not found (404). Page ID ${page_id} may not exist.`,
+              returnDisplay: `Page not found (404): ${page_id}`
+            };
+          }
+          if (!response.ok) {
+            const errorText = await response.text().catch(() => "Unknown error");
+            return {
+              llmContent: `Error: API call failed with status ${response.status}: ${errorText}`,
+              returnDisplay: `API error (${response.status})`
+            };
+          }
+          const pageData = await response.json();
+          const content = pageData.body.storage.value;
+          const spaceKey = pageData.space.key;
+          const title = pageData.title;
+          const version3 = pageData.version.number;
+          const created = pageData.created;
+          const updated = pageData.updated;
+          let pageUrl;
+          if (isCloud) {
+            pageUrl = `${CONFLUENCE_URL}/spaces/${spaceKey}/pages/${pageData.id}`;
+          } else {
+            pageUrl = `${CONFLUENCE_URL}/pages/viewpage.action?pageId=${pageData.id}`;
+          }
+          let processedContent;
+          let contentFormat;
+          if (convert_to_markdown) {
+            processedContent = this.processHtmlContent(content, spaceKey, CONFLUENCE_URL);
+            contentFormat = "markdown";
+          } else {
+            processedContent = content;
+            contentFormat = "storage";
+          }
+          const result = {
+            id: pageData.id,
+            title,
+            type: pageData.type,
+            status: pageData.status,
+            created,
+            updated,
+            url: pageUrl,
+            space: {
+              key: spaceKey,
+              name: pageData.space.name
+            },
+            version: version3,
+            attachments: pageData.children?.attachment?.results || [],
+            ancestors: pageData.ancestors || [],
+            content: {
+              value: processedContent,
+              format: contentFormat
+            }
+          };
+          const resultText = `# ${title}
+
+**Page ID:** ${pageData.id}  
+**Space:** ${spaceKey}  
+**Version:** ${version3}   
+**Created:** ${created}  
+**Updated:** ${updated}  
+**URL:** ${pageUrl}
+
+---
+
+${processedContent}
+`;
+          return {
+            llmContent: resultText,
+            returnDisplay: `Retrieved Confluence page: ${title}`
+          };
+        } catch (error) {
+          const errorMessage = `Error retrieving Confluence page ${page_id}: ${getErrorMessage(error)}`;
+          console.error(errorMessage, error);
+          return {
+            llmContent: `Error: ${errorMessage}`,
+            returnDisplay: `Error: ${errorMessage}`
+          };
+        }
+      }
+    };
+  }
+});
+
+// packages/core/dist/src/tools/jira-get-issue.js
+var JIRA_FETCH_TIMEOUT_MS, JIRA_URL, JiraGetIssueTool;
+var init_jira_get_issue = __esm({
+  "packages/core/dist/src/tools/jira-get-issue.js"() {
+    "use strict";
+    init_schemaValidator();
+    init_tools();
+    init_node();
+    init_errors();
+    JIRA_FETCH_TIMEOUT_MS = 3e4;
+    JIRA_URL = "https://jira.rakuten-it.com/jira";
+    JiraGetIssueTool = class _JiraGetIssueTool extends BaseTool {
+      config;
+      static Name = "jira_get_issue";
+      constructor(config2) {
+        super(_JiraGetIssueTool.Name, "JiraGetIssue", "Retrieves content from a Jira issue by its key. Uses Personal Access Token from keys.json for authentication.", {
+          properties: {
+            issue_key: {
+              description: "The Jira issue key to retrieve (e.g., PROJECT-123)",
+              type: Type.STRING
+            },
+            expand: {
+              description: 'Fields to expand in the response (e.g., "renderedFields,changelog")',
+              type: Type.STRING
+            },
+            comment_limit: {
+              description: 'Maximum number of comments to include (default: 10, use "all" for all comments)',
+              type: Type.STRING
+            }
+          },
+          required: ["issue_key"],
+          type: Type.OBJECT
+        });
+        this.config = config2;
+      }
+      validateParams(params) {
+        const errors = SchemaValidator.validate(this.schema.parameters, params);
+        if (errors) {
+          return errors;
+        }
+        if (!params.issue_key || params.issue_key.trim() === "") {
+          return "The 'issue_key' parameter cannot be empty.";
+        }
+        const issueKeyPattern = /^[A-Z]+-\d+$/;
+        if (!issueKeyPattern.test(params.issue_key.trim())) {
+          return "The 'issue_key' must be in format PROJECT-123 (e.g., PROJ-456)";
+        }
+        return null;
+      }
+      getDescription(params) {
+        return `Retrieving Jira issue ${params.issue_key} from ${JIRA_URL}`;
+      }
+      /**
+       * Normalize comment limit to a number
+       */
+      normalizeCommentLimit(commentLimit) {
+        if (commentLimit === void 0) {
+          return 10;
+        }
+        if (typeof commentLimit === "number") {
+          return commentLimit;
+        }
+        if (commentLimit === "all" || commentLimit === "") {
+          return null;
+        }
+        try {
+          return parseInt(commentLimit, 10);
+        } catch {
+          return 10;
+        }
+      }
+      /**
+       * Convert Jira formatted text to plain text
+       */
+      convertJiraTextToPlainText(content) {
+        if (typeof content === "string") {
+          return content;
+        }
+        if (typeof content === "object" && content !== null) {
+          const obj = content;
+          if (Array.isArray(obj.content)) {
+            return this.extractTextFromContent(obj.content);
+          }
+        }
+        return "";
+      }
+      /**
+       * Extract text from Jira content structure
+       */
+      extractTextFromContent(content) {
+        let text = "";
+        for (const item of content) {
+          if (typeof item === "object" && item !== null) {
+            const obj = item;
+            if (obj.text) {
+              text += obj.text;
+            }
+            if (obj.content && Array.isArray(obj.content)) {
+              text += this.extractTextFromContent(obj.content);
+            }
+          }
+        }
+        return text;
+      }
+      /**
+       * Format date string
+       */
+      formatDate(dateStr) {
+        if (!dateStr) {
+          return "";
+        }
+        try {
+          const date = new Date(dateStr);
+          return date.toLocaleString();
+        } catch {
+          return dateStr;
+        }
+      }
+      async execute(params, signal) {
+        const validationError = this.validateParams(params);
+        if (validationError) {
+          return {
+            llmContent: `Error: Invalid parameters provided. Reason: ${validationError}`,
+            returnDisplay: validationError
+          };
+        }
+        const { issue_key, expand: expand2, comment_limit } = params;
+        const personal_access_token = this.config.getJiraToken();
+        if (!personal_access_token) {
+          return {
+            llmContent: "Error: Jira Personal Access Token not found in keys.json. Please configure it first.",
+            returnDisplay: "Jira token not configured"
+          };
+        }
+        try {
+          const apiUrl = `${JIRA_URL}/rest/api/2/issue/${issue_key}`;
+          const queryParams = new URLSearchParams();
+          const expandParams = expand2 ? expand2.split(",").map((s2) => s2.trim()) : [];
+          if (!expandParams.includes("renderedFields")) {
+            expandParams.push("renderedFields");
+          }
+          if (expandParams.length > 0) {
+            queryParams.set("expand", expandParams.join(","));
+          }
+          const fullUrl = `${apiUrl}?${queryParams.toString()}`;
+          const headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${personal_access_token}`
+          };
+          console.log("Jira API request:", {
+            url: fullUrl,
+            authMethod: "Bearer",
+            tokenLength: personal_access_token.length,
+            headers: { ...headers, Authorization: "Bearer ***" }
+          });
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), JIRA_FETCH_TIMEOUT_MS);
+          let response;
+          try {
+            response = await fetch(fullUrl, {
+              method: "GET",
+              headers,
+              signal: signal || controller.signal
+            });
+          } finally {
+            clearTimeout(timeoutId);
+          }
+          if (response.status === 401) {
+            return {
+              llmContent: "Error: Authentication failed (401). Personal Access Token may be invalid or expired.",
+              returnDisplay: "Authentication failed (401)"
+            };
+          }
+          if (response.status === 403) {
+            return {
+              llmContent: "Error: Access denied (403). Token may not have sufficient permissions.",
+              returnDisplay: "Access denied (403)"
+            };
+          }
+          if (response.status === 404) {
+            return {
+              llmContent: `Error: Issue not found (404). Issue key ${issue_key} may not exist.`,
+              returnDisplay: `Issue not found (404): ${issue_key}`
+            };
+          }
+          if (!response.ok) {
+            const errorText = await response.text().catch(() => "Unknown error");
+            console.error(`Jira API error (${response.status}):`, errorText.substring(0, 500));
+            return {
+              llmContent: `Error: API call failed with status ${response.status}: ${errorText.substring(0, 200)}`,
+              returnDisplay: `API error (${response.status})`
+            };
+          }
+          const contentType = response.headers.get("content-type") || "";
+          if (!contentType.includes("application/json")) {
+            const responseText = await response.text();
+            console.error("Jira API returned non-JSON response:", responseText.substring(0, 500));
+            return {
+              llmContent: "Error: Jira API returned non-JSON response. This usually means authentication failed. Please check your Personal Access Token in keys.json.",
+              returnDisplay: "Authentication failed - invalid response format"
+            };
+          }
+          const issueData = await response.json();
+          const fields = issueData.fields || {};
+          const summary = fields.summary || "";
+          const status = fields.status?.name || "Unknown";
+          const issueType = fields.issuetype?.name || "Unknown";
+          const created = this.formatDate(fields.created);
+          const updated = this.formatDate(fields.updated);
+          const assignee = fields.assignee?.displayName || fields.assignee?.name || "Unassigned";
+          const reporter = fields.reporter?.displayName || fields.reporter?.name || "Unknown";
+          const description = this.convertJiraTextToPlainText(fields.description);
+          const comments = fields.comment?.comments || [];
+          const normalizedCommentLimit = this.normalizeCommentLimit(comment_limit);
+          const limitedComments = normalizedCommentLimit !== null ? comments.slice(0, normalizedCommentLimit) : comments;
+          const issueUrl = `${JIRA_URL}/browse/${issue_key}`;
+          let resultText = `# ${issue_key}: ${summary}
+
+`;
+          resultText += `**Type**: ${issueType}
+`;
+          resultText += `**Status**: ${status}
+`;
+          resultText += `**Reporter**: ${reporter}
+`;
+          resultText += `**Assignee**: ${assignee}
+`;
+          resultText += `**Created**: ${created}
+`;
+          resultText += `**Updated**: ${updated}
+`;
+          resultText += `**URL**: ${issueUrl}
+
+`;
+          if (description) {
+            resultText += `## Description
+
+${description}
+
+`;
+          }
+          if (limitedComments.length > 0) {
+            resultText += `## Comments (${limitedComments.length}${normalizedCommentLimit !== null ? ` of ${comments.length}` : ""})
+
+`;
+            for (const comment of limitedComments) {
+              const commentAuthor = comment.author?.displayName || comment.author?.name || "Unknown";
+              const commentBody = this.convertJiraTextToPlainText(comment.body);
+              const commentCreated = this.formatDate(comment.created);
+              if (commentBody) {
+                resultText += `**${commentAuthor}** (${commentCreated}):
+${commentBody}
+
+`;
+              }
+            }
+          }
+          return {
+            llmContent: resultText,
+            returnDisplay: `Retrieved Jira issue: ${issue_key}`
+          };
+        } catch (error) {
+          const errorMessage = `Error retrieving Jira issue ${issue_key}: ${getErrorMessage(error)}`;
+          console.error(errorMessage, error);
+          return {
+            llmContent: `Error: ${errorMessage}`,
+            returnDisplay: `Error: ${errorMessage}`
+          };
+        }
+      }
+    };
+  }
+});
+
+// packages/core/dist/src/tools/bitbucket-get-pr-diff.js
+var BITBUCKET_FETCH_TIMEOUT_MS, BITBUCKET_URL, BitbucketGetPrDiffTool;
+var init_bitbucket_get_pr_diff = __esm({
+  "packages/core/dist/src/tools/bitbucket-get-pr-diff.js"() {
+    "use strict";
+    init_schemaValidator();
+    init_tools();
+    init_node();
+    init_errors();
+    BITBUCKET_FETCH_TIMEOUT_MS = 3e4;
+    BITBUCKET_URL = "https://git.rakuten-it.com";
+    BitbucketGetPrDiffTool = class _BitbucketGetPrDiffTool extends BaseTool {
+      config;
+      static Name = "bitbucket_get_pr_diff";
+      constructor(config2) {
+        super(_BitbucketGetPrDiffTool.Name, "BitbucketGetPrDiff", "Retrieves the diff content for a specified Bitbucket Pull Request. Uses Personal Access Token from keys.json for authentication.", {
+          properties: {
+            project_key: {
+              description: "The unique identifier for the Bitbucket project that owns the PR",
+              type: Type.STRING
+            },
+            repo_slug: {
+              description: "The repository slug name that owns the PR",
+              type: Type.STRING
+            },
+            pr_id: {
+              description: "The Pull Request unique identifier",
+              type: Type.NUMBER
+            }
+          },
+          required: ["project_key", "repo_slug", "pr_id"],
+          type: Type.OBJECT
+        });
+        this.config = config2;
+      }
+      validateParams(params) {
+        const errors = SchemaValidator.validate(this.schema.parameters, params);
+        if (errors) {
+          return errors;
+        }
+        if (!params.project_key || params.project_key.trim() === "") {
+          return "The 'project_key' parameter cannot be empty.";
+        }
+        if (!params.repo_slug || params.repo_slug.trim() === "") {
+          return "The 'repo_slug' parameter cannot be empty.";
+        }
+        if (params.pr_id <= 0) {
+          return "The 'pr_id' must be a positive number.";
+        }
+        return null;
+      }
+      getDescription(params) {
+        return `Retrieving diff for Bitbucket PR #${params.pr_id} in ${params.project_key}/${params.repo_slug}`;
+      }
+      async execute(params, signal) {
+        const validationError = this.validateParams(params);
+        if (validationError) {
+          return {
+            llmContent: `Error: Invalid parameters provided. Reason: ${validationError}`,
+            returnDisplay: validationError
+          };
+        }
+        const { project_key, repo_slug, pr_id } = params;
+        const personal_access_token = this.config.getBitbucketToken();
+        if (!personal_access_token) {
+          return {
+            llmContent: "Error: Bitbucket Personal Access Token not found in keys.json. Please configure it first.",
+            returnDisplay: "Bitbucket token not configured"
+          };
+        }
+        try {
+          const apiUrl = `${BITBUCKET_URL}/rest/api/1.0/projects/${project_key}/repos/${repo_slug}/pull-requests/${pr_id}/diff`;
+          const headers = {
+            "Authorization": `Bearer ${personal_access_token}`,
+            "Accept": "text/plain"
+          };
+          console.log("Bitbucket API request:", {
+            url: apiUrl,
+            authMethod: "Bearer",
+            tokenLength: personal_access_token.length,
+            headers: { ...headers, Authorization: "Bearer ***" }
+          });
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), BITBUCKET_FETCH_TIMEOUT_MS);
+          let response;
+          try {
+            response = await fetch(apiUrl, {
+              method: "GET",
+              headers,
+              signal: signal || controller.signal
+            });
+          } finally {
+            clearTimeout(timeoutId);
+          }
+          if (response.status === 401) {
+            return {
+              llmContent: "Error: Authentication failed (401). Personal Access Token may be invalid or expired.",
+              returnDisplay: "Authentication failed (401)"
+            };
+          }
+          if (response.status === 403) {
+            return {
+              llmContent: "Error: Access denied (403). Token may not have sufficient permissions.",
+              returnDisplay: "Access denied (403)"
+            };
+          }
+          if (response.status === 404) {
+            return {
+              llmContent: `Error: Pull Request not found (404). PR #${pr_id} in ${project_key}/${repo_slug} may not exist.`,
+              returnDisplay: `PR not found (404): #${pr_id}`
+            };
+          }
+          if (!response.ok) {
+            const errorText = await response.text().catch(() => "Unknown error");
+            console.error(`Bitbucket API error (${response.status}):`, errorText.substring(0, 500));
+            return {
+              llmContent: `Error: API call failed with status ${response.status}: ${errorText.substring(0, 200)}`,
+              returnDisplay: `API error (${response.status})`
+            };
+          }
+          const diffText = await response.text();
+          let resultText = `# Pull Request Diff: ${project_key}/${repo_slug}#${pr_id}
+
+`;
+          resultText += `\`\`\`diff
+${diffText}
+\`\`\``;
+          return {
+            llmContent: resultText,
+            returnDisplay: `Retrieved diff for Bitbucket PR #${pr_id}`
+          };
+        } catch (error) {
+          const errorMessage = `Error retrieving Bitbucket PR diff ${project_key}/${repo_slug}#${pr_id}: ${getErrorMessage(error)}`;
+          console.error(errorMessage, error);
+          return {
+            llmContent: `Error: ${errorMessage}`,
+            returnDisplay: `Error: ${errorMessage}`
+          };
+        }
+      }
+    };
+  }
+});
+
+// packages/core/dist/src/tools/bitbucket-add-pr-comment.js
+var BITBUCKET_FETCH_TIMEOUT_MS2, BITBUCKET_URL2, BitbucketAddPrCommentTool;
+var init_bitbucket_add_pr_comment = __esm({
+  "packages/core/dist/src/tools/bitbucket-add-pr-comment.js"() {
+    "use strict";
+    init_schemaValidator();
+    init_tools();
+    init_node();
+    init_errors();
+    BITBUCKET_FETCH_TIMEOUT_MS2 = 3e4;
+    BITBUCKET_URL2 = "https://git.rakuten-it.com";
+    BitbucketAddPrCommentTool = class _BitbucketAddPrCommentTool extends BaseTool {
+      config;
+      static Name = "bitbucket_add_pr_comment";
+      constructor(config2) {
+        super(_BitbucketAddPrCommentTool.Name, "BitbucketAddPrComment", "Adds a general comment to a specified Bitbucket Pull Request. Uses Personal Access Token from keys.json for authentication.", {
+          properties: {
+            project_key: {
+              description: "The unique identifier for the Bitbucket project that owns the PR",
+              type: Type.STRING
+            },
+            repo_slug: {
+              description: "The repository slug name that owns the PR",
+              type: Type.STRING
+            },
+            pr_id: {
+              description: "The Pull Request unique identifier",
+              type: Type.NUMBER
+            },
+            comment_text: {
+              description: "The text content of the comment to add",
+              type: Type.STRING
+            }
+          },
+          required: ["project_key", "repo_slug", "pr_id", "comment_text"],
+          type: Type.OBJECT
+        });
+        this.config = config2;
+      }
+      validateParams(params) {
+        const errors = SchemaValidator.validate(this.schema.parameters, params);
+        if (errors) {
+          return errors;
+        }
+        if (!params.project_key || params.project_key.trim() === "") {
+          return "The 'project_key' parameter cannot be empty.";
+        }
+        if (!params.repo_slug || params.repo_slug.trim() === "") {
+          return "The 'repo_slug' parameter cannot be empty.";
+        }
+        if (params.pr_id <= 0) {
+          return "The 'pr_id' must be a positive number.";
+        }
+        if (!params.comment_text || params.comment_text.trim() === "") {
+          return "The 'comment_text' parameter cannot be empty.";
+        }
+        return null;
+      }
+      getDescription(params) {
+        return `Adding comment to Bitbucket PR #${params.pr_id} in ${params.project_key}/${params.repo_slug}`;
+      }
+      async execute(params, signal) {
+        const validationError = this.validateParams(params);
+        if (validationError) {
+          return {
+            llmContent: `Error: Invalid parameters provided. Reason: ${validationError}`,
+            returnDisplay: validationError
+          };
+        }
+        const { project_key, repo_slug, pr_id, comment_text } = params;
+        const personal_access_token = this.config.getBitbucketToken();
+        if (!personal_access_token) {
+          return {
+            llmContent: "Error: Bitbucket Personal Access Token not found in keys.json. Please configure it first.",
+            returnDisplay: "Bitbucket token not configured"
+          };
+        }
+        try {
+          const apiUrl = `${BITBUCKET_URL2}/rest/api/latest/projects/${project_key}/repos/${repo_slug}/pull-requests/${pr_id}/comments`;
+          const headers = {
+            "Authorization": `Bearer ${personal_access_token}`,
+            "Content-Type": "application/json"
+          };
+          const payload = {
+            text: comment_text
+          };
+          console.log("Bitbucket API request:", {
+            url: apiUrl,
+            method: "POST",
+            authMethod: "Bearer",
+            tokenLength: personal_access_token.length,
+            headers: { ...headers, Authorization: "Bearer ***" }
+          });
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), BITBUCKET_FETCH_TIMEOUT_MS2);
+          let response;
+          try {
+            response = await fetch(apiUrl, {
+              method: "POST",
+              headers,
+              body: JSON.stringify(payload),
+              signal: signal || controller.signal
+            });
+          } finally {
+            clearTimeout(timeoutId);
+          }
+          if (response.status === 401) {
+            return {
+              llmContent: "Error: Authentication failed (401). Personal Access Token may be invalid or expired.",
+              returnDisplay: "Authentication failed (401)"
+            };
+          }
+          if (response.status === 403) {
+            return {
+              llmContent: "Error: Access denied (403). Token may not have sufficient permissions.",
+              returnDisplay: "Access denied (403)"
+            };
+          }
+          if (response.status === 404) {
+            return {
+              llmContent: `Error: Pull Request not found (404). PR #${pr_id} in ${project_key}/${repo_slug} may not exist.`,
+              returnDisplay: `PR not found (404): #${pr_id}`
+            };
+          }
+          if (!response.ok) {
+            const errorText = await response.text().catch(() => "Unknown error");
+            console.error(`Bitbucket API error (${response.status}):`, errorText.substring(0, 500));
+            return {
+              llmContent: `Error: API call failed with status ${response.status}: ${errorText.substring(0, 200)}`,
+              returnDisplay: `API error (${response.status})`
+            };
+          }
+          const responseData = await response.json();
+          let resultText = `# Comment added to Pull Request: ${project_key}/${repo_slug}#${pr_id}
+
+`;
+          resultText += `**Comment ID**: ${responseData.id || "Unknown"}
+`;
+          resultText += `**Text**: ${comment_text}
+`;
+          return {
+            llmContent: resultText,
+            returnDisplay: `Added comment to Bitbucket PR #${pr_id}`
+          };
+        } catch (error) {
+          const errorMessage = `Error adding comment to Bitbucket PR ${project_key}/${repo_slug}#${pr_id}: ${getErrorMessage(error)}`;
+          console.error(errorMessage, error);
+          return {
+            llmContent: `Error: ${errorMessage}`,
+            returnDisplay: `Error: ${errorMessage}`
+          };
+        }
+      }
+    };
+  }
+});
+
+// packages/core/dist/src/tools/bitbucket-add-pr-inline-comment.js
+var BITBUCKET_FETCH_TIMEOUT_MS3, BITBUCKET_URL3, BitbucketAddPrInlineCommentTool;
+var init_bitbucket_add_pr_inline_comment = __esm({
+  "packages/core/dist/src/tools/bitbucket-add-pr-inline-comment.js"() {
+    "use strict";
+    init_schemaValidator();
+    init_tools();
+    init_node();
+    init_errors();
+    BITBUCKET_FETCH_TIMEOUT_MS3 = 3e4;
+    BITBUCKET_URL3 = "https://git.rakuten-it.com";
+    BitbucketAddPrInlineCommentTool = class _BitbucketAddPrInlineCommentTool extends BaseTool {
+      config;
+      static Name = "bitbucket_add_pr_inline_comment";
+      constructor(config2) {
+        super(_BitbucketAddPrInlineCommentTool.Name, "BitbucketAddPrInlineComment", "Adds an inline comment to a specific file and line in a Bitbucket Pull Request diff. Uses Personal Access Token from keys.json for authentication.", {
+          properties: {
+            project_key: {
+              description: "The unique identifier for the Bitbucket project that owns the PR",
+              type: Type.STRING
+            },
+            repo_slug: {
+              description: "The repository slug name that owns the PR",
+              type: Type.STRING
+            },
+            pr_id: {
+              description: "The Pull Request unique identifier",
+              type: Type.NUMBER
+            },
+            file_path: {
+              description: "The file path relative to repository root to add comment to",
+              type: Type.STRING
+            },
+            line: {
+              description: "The line number to add comment to",
+              type: Type.NUMBER
+            },
+            comment_text: {
+              description: "The text content of the inline comment to add",
+              type: Type.STRING
+            },
+            line_type: {
+              description: "The line type, default is ADDED, optional values: ADDED, REMOVED, CONTEXT",
+              type: Type.STRING
+            },
+            file_type: {
+              description: "The file type, default is TO, optional values: TO, FROM",
+              type: Type.STRING
+            }
+          },
+          required: ["project_key", "repo_slug", "pr_id", "file_path", "line", "comment_text"],
+          type: Type.OBJECT
+        });
+        this.config = config2;
+      }
+      validateParams(params) {
+        const errors = SchemaValidator.validate(this.schema.parameters, params);
+        if (errors) {
+          return errors;
+        }
+        if (!params.project_key || params.project_key.trim() === "") {
+          return "The 'project_key' parameter cannot be empty.";
+        }
+        if (!params.repo_slug || params.repo_slug.trim() === "") {
+          return "The 'repo_slug' parameter cannot be empty.";
+        }
+        if (params.pr_id <= 0) {
+          return "The 'pr_id' must be a positive number.";
+        }
+        if (!params.file_path || params.file_path.trim() === "") {
+          return "The 'file_path' parameter cannot be empty.";
+        }
+        if (params.line <= 0) {
+          return "The 'line' must be a positive number.";
+        }
+        if (!params.comment_text || params.comment_text.trim() === "") {
+          return "The 'comment_text' parameter cannot be empty.";
+        }
+        if (params.line_type && !["ADDED", "REMOVED", "CONTEXT"].includes(params.line_type)) {
+          return "The 'line_type' must be one of: ADDED, REMOVED, CONTEXT";
+        }
+        if (params.file_type && !["TO", "FROM"].includes(params.file_type)) {
+          return "The 'file_type' must be one of: TO, FROM";
+        }
+        return null;
+      }
+      getDescription(params) {
+        return `Adding inline comment to Bitbucket PR #${params.pr_id} in ${params.project_key}/${params.repo_slug} at ${params.file_path}:${params.line}`;
+      }
+      async execute(params, signal) {
+        const validationError = this.validateParams(params);
+        if (validationError) {
+          return {
+            llmContent: `Error: Invalid parameters provided. Reason: ${validationError}`,
+            returnDisplay: validationError
+          };
+        }
+        const { project_key, repo_slug, pr_id, file_path, line, comment_text, line_type, file_type } = params;
+        const personal_access_token = this.config.getBitbucketToken();
+        if (!personal_access_token) {
+          return {
+            llmContent: "Error: Bitbucket Personal Access Token not found in keys.json. Please configure it first.",
+            returnDisplay: "Bitbucket token not configured"
+          };
+        }
+        try {
+          const apiUrl = `${BITBUCKET_URL3}/rest/api/latest/projects/${project_key}/repos/${repo_slug}/pull-requests/${pr_id}/comments`;
+          const headers = {
+            "Authorization": `Bearer ${personal_access_token}`,
+            "Content-Type": "application/json"
+          };
+          const payload = {
+            text: comment_text,
+            anchor: {
+              path: file_path,
+              line,
+              lineType: line_type || "ADDED",
+              fileType: file_type || "TO"
+            }
+          };
+          console.log("Bitbucket API request:", {
+            url: apiUrl,
+            method: "POST",
+            authMethod: "Bearer",
+            tokenLength: personal_access_token.length,
+            headers: { ...headers, Authorization: "Bearer ***" }
+          });
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), BITBUCKET_FETCH_TIMEOUT_MS3);
+          let response;
+          try {
+            response = await fetch(apiUrl, {
+              method: "POST",
+              headers,
+              body: JSON.stringify(payload),
+              signal: signal || controller.signal
+            });
+          } finally {
+            clearTimeout(timeoutId);
+          }
+          if (response.status === 401) {
+            return {
+              llmContent: "Error: Authentication failed (401). Personal Access Token may be invalid or expired.",
+              returnDisplay: "Authentication failed (401)"
+            };
+          }
+          if (response.status === 403) {
+            return {
+              llmContent: "Error: Access denied (403). Token may not have sufficient permissions.",
+              returnDisplay: "Access denied (403)"
+            };
+          }
+          if (response.status === 404) {
+            return {
+              llmContent: `Error: Pull Request not found (404). PR #${pr_id} in ${project_key}/${repo_slug} may not exist.`,
+              returnDisplay: `PR not found (404): #${pr_id}`
+            };
+          }
+          if (!response.ok) {
+            const errorText = await response.text().catch(() => "Unknown error");
+            console.error(`Bitbucket API error (${response.status}):`, errorText.substring(0, 500));
+            return {
+              llmContent: `Error: API call failed with status ${response.status}: ${errorText.substring(0, 200)}`,
+              returnDisplay: `API error (${response.status})`
+            };
+          }
+          const responseData = await response.json();
+          let resultText = `# Inline comment added to Pull Request: ${project_key}/${repo_slug}#${pr_id}
+
+`;
+          resultText += `**File**: ${file_path}
+`;
+          resultText += `**Line**: ${line}
+`;
+          resultText += `**Line Type**: ${line_type || "ADDED"}
+`;
+          resultText += `**File Type**: ${file_type || "TO"}
+`;
+          resultText += `**Comment ID**: ${responseData.id || "Unknown"}
+`;
+          resultText += `**Text**: ${comment_text}
+`;
+          return {
+            llmContent: resultText,
+            returnDisplay: `Added inline comment to Bitbucket PR #${pr_id} at ${file_path}:${line}`
+          };
+        } catch (error) {
+          const errorMessage = `Error adding inline comment to Bitbucket PR ${project_key}/${repo_slug}#${pr_id}: ${getErrorMessage(error)}`;
+          console.error(errorMessage, error);
+          return {
+            llmContent: `Error: ${errorMessage}`,
+            returnDisplay: `Error: ${errorMessage}`
+          };
+        }
+      }
+    };
+  }
+});
+
 // packages/core/dist/src/utils/getFolderStructure.js
 import * as fs18 from "fs/promises";
 import * as path17 from "path";
@@ -126835,7 +127826,7 @@ import fs20 from "node:fs";
 import process20 from "node:process";
 function getCoreSystemPrompt(userMemory) {
   let systemMdEnabled = false;
-  let systemMdPath = path19.join(GEMINI_CONFIG_DIR, "system.md");
+  let systemMdPath = path19.join(MPDAI_CONFIG_DIR, "system.md");
   const systemMdVar = process20.env.GEMINI_SYSTEM_MD?.toLowerCase();
   if (systemMdVar && !["0", "false"].includes(systemMdVar)) {
     systemMdEnabled = true;
@@ -174596,7 +175587,7 @@ var require_homedir = __commonJS({
   "node_modules/resolve/lib/homedir.js"(exports2, module2) {
     "use strict";
     var os23 = __require("os");
-    module2.exports = os23.homedir || function homedir16() {
+    module2.exports = os23.homedir || function homedir17() {
       var home = process.env.HOME;
       var user = process.env.LOGNAME || process.env.USER || process.env.LNAME || process.env.USERNAME;
       if (process.platform === "win32") {
@@ -175077,11 +176068,11 @@ var require_async2 = __commonJS({
     var normalizeOptions = require_normalize_options();
     var isCore = require_is_core_module();
     var realpathFS = process.platform !== "win32" && fs51.realpath && typeof fs51.realpath.native === "function" ? fs51.realpath.native : fs51.realpath;
-    var homedir16 = getHomedir();
+    var homedir17 = getHomedir();
     var defaultPaths = function() {
       return [
-        path53.join(homedir16, ".node_modules"),
-        path53.join(homedir16, ".node_libraries")
+        path53.join(homedir17, ".node_modules"),
+        path53.join(homedir17, ".node_libraries")
       ];
     };
     var defaultIsFile = function isFile(file, cb) {
@@ -175567,11 +176558,11 @@ var require_sync = __commonJS({
     var nodeModulesPaths = require_node_modules_paths();
     var normalizeOptions = require_normalize_options();
     var realpathFS = process.platform !== "win32" && fs51.realpathSync && typeof fs51.realpathSync.native === "function" ? fs51.realpathSync.native : fs51.realpathSync;
-    var homedir16 = getHomedir();
+    var homedir17 = getHomedir();
     var defaultPaths = function() {
       return [
-        path53.join(homedir16, ".node_modules"),
-        path53.join(homedir16, ".node_libraries")
+        path53.join(homedir17, ".node_modules"),
+        path53.join(homedir17, ".node_libraries")
       ];
     };
     var defaultIsFile = function isFile(file) {
@@ -175608,8 +176599,8 @@ var require_sync = __commonJS({
       }
       return x;
     };
-    var defaultReadPackageSync = function defaultReadPackageSync2(readFileSync16, pkgfile) {
-      var body = readFileSync16(pkgfile);
+    var defaultReadPackageSync = function defaultReadPackageSync2(readFileSync19, pkgfile) {
+      var body = readFileSync19(pkgfile);
       try {
         var pkg2 = JSON.parse(body);
         return pkg2;
@@ -175629,7 +176620,7 @@ var require_sync = __commonJS({
       }
       var opts = normalizeOptions(x, options);
       var isFile = opts.isFile || defaultIsFile;
-      var readFileSync16 = opts.readFileSync || fs51.readFileSync;
+      var readFileSync19 = opts.readFileSync || fs51.readFileSync;
       var isDirectory = opts.isDirectory || defaultIsDir;
       var realpathSync2 = opts.realpathSync || defaultRealpathSync;
       var readPackageSync2 = opts.readPackageSync || defaultReadPackageSync;
@@ -175686,7 +176677,7 @@ var require_sync = __commonJS({
         if (!isFile(pkgfile)) {
           return loadpkg(path53.dirname(dir));
         }
-        var pkg2 = readPackageSync2(readFileSync16, pkgfile);
+        var pkg2 = readPackageSync2(readFileSync19, pkgfile);
         if (pkg2 && opts.packageFilter) {
           pkg2 = opts.packageFilter(
             pkg2,
@@ -175700,7 +176691,7 @@ var require_sync = __commonJS({
         var pkgfile = path53.join(maybeRealpathSync(realpathSync2, x2, opts), "/package.json");
         if (isFile(pkgfile)) {
           try {
-            var pkg2 = readPackageSync2(readFileSync16, pkgfile);
+            var pkg2 = readPackageSync2(readFileSync19, pkgfile);
           } catch (e2) {
           }
           if (pkg2 && opts.packageFilter) {
@@ -180708,7 +181699,7 @@ var init_user_id = __esm({
     "use strict";
     init_paths();
     homeDir = os7.homedir() ?? "";
-    geminiDir = path20.join(homeDir, GEMINI_DIR2);
+    geminiDir = path20.join(homeDir, MPDAI_DIR2);
     installationIdFile = path20.join(geminiDir, "installation_id");
   }
 });
@@ -203445,7 +204436,7 @@ var init_fileDiscoveryService = __esm({
     "use strict";
     init_gitIgnoreParser();
     init_gitUtils();
-    GEMINI_IGNORE_FILE_NAME = ".geminiignore";
+    GEMINI_IGNORE_FILE_NAME = ".mpdaiignore";
     FileDiscoveryService = class {
       gitIgnoreFilter = null;
       geminiIgnoreFilter = null;
@@ -203516,7 +204507,7 @@ var init_fileDiscoveryService = __esm({
         return false;
       }
       /**
-       * Returns loaded patterns from .geminiignore
+       * Returns loaded patterns from .mpdaiignore
        */
       getGeminiIgnorePatterns() {
         return this.geminiIgnoreFilter?.getPatterns() ?? [];
@@ -208065,7 +209056,7 @@ var init_gitService = __esm({
       }
       getHistoryDir() {
         const hash = getProjectHash(this.projectRoot);
-        return path23.join(os8.homedir(), GEMINI_DIR2, "history", hash);
+        return path23.join(os8.homedir(), MPDAI_DIR2, "history", hash);
       }
       async initialize() {
         if (!isGitRepository(this.projectRoot)) {
@@ -208346,7 +209337,7 @@ async function getGeminiMdFilePathsInternal(currentWorkingDirectory, userHomePat
   for (const geminiMdFilename of geminiMdFilenames) {
     const resolvedCwd = path26.resolve(currentWorkingDirectory);
     const resolvedHome = path26.resolve(userHomePath);
-    const globalMemoryPath = path26.join(resolvedHome, GEMINI_CONFIG_DIR, geminiMdFilename);
+    const globalMemoryPath = path26.join(resolvedHome, MPDAI_CONFIG_DIR, geminiMdFilename);
     if (debugMode)
       logger3.debug(`Searching for ${geminiMdFilename} starting from CWD: ${resolvedCwd}`);
     if (debugMode)
@@ -208370,7 +209361,7 @@ async function getGeminiMdFilePathsInternal(currentWorkingDirectory, userHomePat
       if (debugMode) {
         logger3.debug(`Checking for ${geminiMdFilename} in (upward scan): ${currentDir}`);
       }
-      if (currentDir === path26.join(resolvedHome, GEMINI_CONFIG_DIR)) {
+      if (currentDir === path26.join(resolvedHome, MPDAI_CONFIG_DIR)) {
         if (debugMode) {
           logger3.debug(`Upward scan reached global config dir path, stopping upward search here: ${currentDir}`);
         }
@@ -208516,6 +209507,9 @@ var init_telemetry = __esm({
 // packages/core/dist/src/config/config.js
 import * as path27 from "node:path";
 import process21 from "node:process";
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "node:fs";
+import { join as join11 } from "node:path";
+import { homedir as homedir6 } from "node:os";
 var ApprovalMode, MCPServerConfig, Config;
 var init_config2 = __esm({
   "packages/core/dist/src/config/config.js"() {
@@ -208532,6 +209526,11 @@ var init_config2 = __esm({
     init_read_many_files();
     init_web_fetch();
     init_web_search();
+    init_confluence_get_page();
+    init_jira_get_issue();
+    init_bitbucket_get_pr_diff();
+    init_bitbucket_add_pr_comment();
+    init_bitbucket_add_pr_inline_comment();
     init_memoryTool();
     init_client3();
     init_fileDiscoveryService();
@@ -208798,7 +209797,7 @@ var init_config2 = __esm({
         return this.geminiClient;
       }
       getGeminiDir() {
-        return path27.join(this.targetDir, GEMINI_CONFIG_DIR);
+        return path27.join(this.targetDir, MPDAI_CONFIG_DIR);
       }
       getProjectTempDir() {
         return getProjectTempDir(this.getProjectRoot());
@@ -208852,6 +209851,72 @@ var init_config2 = __esm({
         this.setGeminiMdFileCount(fileCount);
         return { memoryContent, fileCount };
       }
+      /**
+       * Get Confluence Advanced Access Token from keys.json
+       * @returns The Personal Access Token or null if not found
+       */
+      getConfluenceToken() {
+        try {
+          const keysJsonPath = join11(homedir6(), ".mpdai", "keys.json");
+          if (!existsSync6(keysJsonPath)) {
+            return null;
+          }
+          const content = readFileSync6(keysJsonPath, "utf-8");
+          const keys = JSON.parse(content);
+          const confluenceKey = keys.find((key) => key.name === "confluence");
+          if (confluenceKey && confluenceKey.value1) {
+            return confluenceKey.value1;
+          }
+          return null;
+        } catch (error) {
+          console.error("Failed to read Confluence token from keys.json:", error);
+          return null;
+        }
+      }
+      /**
+       * Get Jira Personal Access Token from keys.json
+       * @returns The Personal Access Token or null if not found
+       */
+      getJiraToken() {
+        try {
+          const keysJsonPath = join11(homedir6(), ".mpdai", "keys.json");
+          if (!existsSync6(keysJsonPath)) {
+            return null;
+          }
+          const content = readFileSync6(keysJsonPath, "utf-8");
+          const keys = JSON.parse(content);
+          const jiraKey = keys.find((key) => key.name === "jira");
+          if (jiraKey && jiraKey.value1) {
+            return jiraKey.value1;
+          }
+          return null;
+        } catch (error) {
+          console.error("Failed to read Jira token from keys.json:", error);
+          return null;
+        }
+      }
+      /**
+       * Get Bitbucket Personal Access Token from keys.json
+       * @returns The Personal Access Token or null if not found
+       */
+      getBitbucketToken() {
+        try {
+          const keysJsonPath = join11(homedir6(), ".mpdai", "keys.json");
+          if (!existsSync6(keysJsonPath)) {
+            return null;
+          }
+          const content = readFileSync6(keysJsonPath, "utf-8");
+          const keys = JSON.parse(content);
+          const bitbucketKey = keys.find((key) => key.name === "bitbucket");
+          if (bitbucketKey && bitbucketKey.value1) {
+            return bitbucketKey.value1;
+          }
+          return null;
+        } catch (error) {
+          console.error("Failed to read Bitbucket token from keys.json:", error);
+          return null;
+        }
+      }
       async createToolRegistry() {
         const registry = new ToolRegistry(this);
         const targetDir = this.getTargetDir();
@@ -208884,9 +209949,24 @@ var init_config2 = __esm({
           registerCoreTool(EditTool, this);
           registerCoreTool(WriteFileTool, this);
         }
-        if (process21.env.USE_GEMINI_TOOL) {
+        const useMpdaiTool = process21.env.USE_MPDAI_TOOL !== "false";
+        if (useMpdaiTool) {
           registerCoreTool(WebFetchTool, this);
           registerCoreTool(WebSearchTool, this);
+          const confluenceToken = this.getConfluenceToken();
+          if (confluenceToken) {
+            registerCoreTool(ConfluenceGetPageTool, this);
+          }
+          const jiraToken = this.getJiraToken();
+          if (jiraToken) {
+            registerCoreTool(JiraGetIssueTool, this);
+          }
+          const bitbucketToken = this.getBitbucketToken();
+          if (bitbucketToken) {
+            registerCoreTool(BitbucketGetPrDiffTool, this);
+            registerCoreTool(BitbucketAddPrCommentTool, this);
+            registerCoreTool(BitbucketAddPrInlineCommentTool, this);
+          }
         }
         await registry.discoverTools();
         return registry;
@@ -209923,8 +211003,6 @@ __export(dist_exports, {
   EndSessionEvent: () => EndSessionEvent,
   FileDiscoveryService: () => FileDiscoveryService,
   ForbiddenError: () => ForbiddenError,
-  GEMINI_CONFIG_DIR: () => GEMINI_CONFIG_DIR,
-  GEMINI_DIR: () => GEMINI_DIR2,
   GeminiChat: () => GeminiChat,
   GeminiClient: () => GeminiClient,
   GeminiEventType: () => GeminiEventType,
@@ -209940,6 +211018,8 @@ __export(dist_exports, {
   MCPServerStatus: () => MCPServerStatus,
   MCP_DEFAULT_TIMEOUT_MSEC: () => MCP_DEFAULT_TIMEOUT_MSEC,
   MEMORY_SECTION_HEADER: () => MEMORY_SECTION_HEADER,
+  MPDAI_CONFIG_DIR: () => MPDAI_CONFIG_DIR,
+  MPDAI_DIR: () => MPDAI_DIR2,
   MemoryTool: () => MemoryTool,
   MessageSenderType: () => MessageSenderType,
   OnboardUserStatusCode: () => OnboardUserStatusCode,
@@ -214095,9 +215175,9 @@ var init_lib3 = __esm({
 });
 
 // packages/cli/src/telemetry/langfuseConfig.ts
-import { readFileSync as readFileSync6, existsSync as existsSync6 } from "fs";
-import { join as join11 } from "path";
-import { homedir as homedir6 } from "os";
+import { readFileSync as readFileSync7, existsSync as existsSync7 } from "fs";
+import { join as join12 } from "path";
+import { homedir as homedir7 } from "os";
 var LangfuseConfigManager;
 var init_langfuseConfig = __esm({
   "packages/cli/src/telemetry/langfuseConfig.ts"() {
@@ -214118,15 +215198,15 @@ var init_langfuseConfig = __esm({
           return this.config;
         }
         try {
-          const userConfigPath = join11(homedir6(), ".gemini", "settings.conf");
-          if (existsSync6(userConfigPath)) {
-            const configContent = readFileSync6(userConfigPath, "utf-8");
+          const userConfigPath = join12(homedir7(), ".mpdai", "settings.conf");
+          if (existsSync7(userConfigPath)) {
+            const configContent = readFileSync7(userConfigPath, "utf-8");
             this.config = JSON.parse(configContent);
             return this.config;
           }
-          const projectConfigPath = join11(process.cwd(), ".langfuse", "settings.conf");
-          if (existsSync6(projectConfigPath)) {
-            const configContent = readFileSync6(projectConfigPath, "utf-8");
+          const projectConfigPath = join12(process.cwd(), ".langfuse", "settings.conf");
+          if (existsSync7(projectConfigPath)) {
+            const configContent = readFileSync7(projectConfigPath, "utf-8");
             this.config = JSON.parse(configContent);
             return this.config;
           }
@@ -214158,9 +215238,9 @@ var init_langfuseConfig = __esm({
 });
 
 // packages/cli/src/telemetry/langfuseClient.ts
-import { join as join12 } from "path";
-import { homedir as homedir7 } from "os";
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
+import { join as join13 } from "path";
+import { homedir as homedir8 } from "os";
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
 var LangfuseClient;
 var init_langfuseClient = __esm({
   "packages/cli/src/telemetry/langfuseClient.ts"() {
@@ -214262,7 +215342,7 @@ var init_langfuseClient = __esm({
             userId,
             metadata: {
               ...safeMetadata,
-              cli_version: this.safeString("0.1.25", "unknown"),
+              cli_version: this.safeString("0.1.31", "unknown"),
               model: this.safeString(process.env.CUSTOM_LLM_MODEL_NAME, "gemini"),
               auth_type: process.env.USE_CUSTOM_LLM ? "custom_llm" : "google_oauth",
               environment: this.safeString(this.configManager.getConfig()?.environment, "unknown")
@@ -214574,9 +215654,9 @@ var init_langfuseClient = __esm({
       // 获取用户ID
       getUserId() {
         try {
-          const userJsonPath = join12(homedir7(), ".gemini", "user.json");
-          if (existsSync7(userJsonPath)) {
-            const content = readFileSync7(userJsonPath, "utf-8");
+          const userJsonPath = join13(homedir8(), ".mpdai", "user.json");
+          if (existsSync8(userJsonPath)) {
+            const content = readFileSync8(userJsonPath, "utf-8");
             const userData = JSON.parse(content);
             if (userData.username) {
               return userData.username;
@@ -215429,7 +216509,7 @@ var init_langfuseIntegration = __esm({
           const metadata = {
             model: this.config.getModel(),
             auth_type: this.config.getContentGeneratorConfig()?.authType,
-            cli_version: "0.1.25",
+            cli_version: "0.1.31",
             start_time: (/* @__PURE__ */ new Date()).toISOString(),
             session_id: this.sessionId
           };
@@ -215488,7 +216568,7 @@ var init_langfuseIntegration = __esm({
             totalCachedTokens: sessionStats.totalCachedTokens,
             totalPromptTokens: sessionStats.totalPromptTokens,
             metadata: {
-              cli_version: "0.1.25",
+              cli_version: "0.1.31",
               auth_type: this.config.getContentGeneratorConfig()?.authType,
               session_end_time: (/* @__PURE__ */ new Date()).toISOString()
             }
@@ -215560,7 +216640,7 @@ var init_langfuseIntegration = __esm({
             error,
             metadata: {
               session_id: this.sessionId,
-              cli_version: "0.1.25",
+              cli_version: "0.1.31",
               auth_type: this.config.getContentGeneratorConfig()?.authType
             }
           });
@@ -220730,9 +221810,9 @@ var require_normalize2 = __commonJS({
 });
 
 // packages/cli/src/config/mpdaiConfig.ts
-import { readFileSync as readFileSync8, existsSync as existsSync9 } from "fs";
-import { join as join14 } from "path";
-import { homedir as homedir9 } from "os";
+import { readFileSync as readFileSync9, existsSync as existsSync10 } from "fs";
+import { join as join15 } from "path";
+import { homedir as homedir10 } from "os";
 var MpdaiConfigManager;
 var init_mpdaiConfig = __esm({
   "packages/cli/src/config/mpdaiConfig.ts"() {
@@ -220753,15 +221833,15 @@ var init_mpdaiConfig = __esm({
           return this.config;
         }
         try {
-          const userConfigPath = join14(homedir9(), ".gemini", "config.json");
-          if (existsSync9(userConfigPath)) {
-            const configContent = readFileSync8(userConfigPath, "utf-8");
+          const userConfigPath = join15(homedir10(), ".mpdai", "config.json");
+          if (existsSync10(userConfigPath)) {
+            const configContent = readFileSync9(userConfigPath, "utf-8");
             this.config = JSON.parse(configContent);
             return this.config;
           }
-          const projectConfigPath = join14(process.cwd(), ".mpdai", "config.json");
-          if (existsSync9(projectConfigPath)) {
-            const configContent = readFileSync8(projectConfigPath, "utf-8");
+          const projectConfigPath = join15(process.cwd(), ".mpdai", "config.json");
+          if (existsSync10(projectConfigPath)) {
+            const configContent = readFileSync9(projectConfigPath, "utf-8");
             this.config = JSON.parse(configContent);
             return this.config;
           }
@@ -222015,9 +223095,9 @@ var EnvConfigManager_exports = {};
 __export(EnvConfigManager_exports, {
   EnvConfigManager: () => EnvConfigManager
 });
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync3, existsSync as existsSync10, mkdirSync as mkdirSync3 } from "fs";
-import { join as join15, dirname as dirname6 } from "path";
-import { homedir as homedir10 } from "os";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync3, existsSync as existsSync11, mkdirSync as mkdirSync3 } from "fs";
+import { join as join16, dirname as dirname6 } from "path";
+import { homedir as homedir11 } from "os";
 var EnvConfigManager;
 var init_EnvConfigManager = __esm({
   "packages/cli/src/services/EnvConfigManager.ts"() {
@@ -222026,7 +223106,7 @@ var init_EnvConfigManager = __esm({
       envPaths;
       constructor() {
         this.envPaths = [
-          ".gemini/.env",
+          ".mpdai/.env",
           // 项目级别的gemini配置
           ".env"
           // 项目级别的通用配置
@@ -222039,17 +223119,17 @@ var init_EnvConfigManager = __esm({
         let currentDir = startDir;
         while (true) {
           for (const envPath of this.envPaths) {
-            const fullPath = join15(currentDir, envPath);
-            if (existsSync10(fullPath)) {
+            const fullPath = join16(currentDir, envPath);
+            if (existsSync11(fullPath)) {
               return fullPath;
             }
           }
-          const parentDir = join15(currentDir, "..");
+          const parentDir = join16(currentDir, "..");
           if (parentDir === currentDir) {
-            const homeDir2 = homedir10();
+            const homeDir2 = homedir11();
             for (const envPath of this.envPaths) {
-              const fullPath = join15(homeDir2, envPath);
-              if (existsSync10(fullPath)) {
+              const fullPath = join16(homeDir2, envPath);
+              if (existsSync11(fullPath)) {
                 return fullPath;
               }
             }
@@ -222064,7 +223144,7 @@ var init_EnvConfigManager = __esm({
        */
       readEnvFile(envPath) {
         try {
-          const content = readFileSync9(envPath, "utf-8");
+          const content = readFileSync10(envPath, "utf-8");
           const envVars = {};
           content.split("\n").forEach((line) => {
             line = line.trim();
@@ -222109,7 +223189,7 @@ var init_EnvConfigManager = __esm({
         const isDebugMode = process.env.DEBUG === "true" || process.env.DEBUG_MODE === "true" || process.env.dev === "true";
         try {
           const dir = dirname6(envPath);
-          if (!existsSync10(dir)) {
+          if (!existsSync11(dir)) {
             mkdirSync3(dir, { recursive: true });
           }
           const envContent = Object.entries(envConfig).map(([key, value]) => `${key}=${value}`).join("\n") + "\n";
@@ -222126,8 +223206,8 @@ var init_EnvConfigManager = __esm({
        * 更新或创建.env文件
        */
       updateEnvFile(model, targetPath) {
-        const envPath = targetPath || this.findEnvFile(process.cwd()) || join15(process.cwd(), ".gemini", ".env");
-        const existingConfig = existsSync10(envPath) ? this.readEnvFile(envPath) : {};
+        const envPath = targetPath || this.findEnvFile(process.cwd()) || join16(process.cwd(), ".mpdai", ".env");
+        const existingConfig = existsSync11(envPath) ? this.readEnvFile(envPath) : {};
         const newConfig = this.generateEnvConfig(model, existingConfig);
         this.writeEnvFile(newConfig, envPath);
         return envPath;
@@ -222512,9 +223592,9 @@ var AuthService_exports = {};
 __export(AuthService_exports, {
   AuthService: () => AuthService
 });
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync4, existsSync as existsSync11, mkdirSync as mkdirSync4 } from "fs";
-import { join as join16 } from "path";
-import { homedir as homedir11 } from "os";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync4, existsSync as existsSync12, mkdirSync as mkdirSync4 } from "fs";
+import { join as join17 } from "path";
+import { homedir as homedir12 } from "os";
 var readlineSync, AuthService;
 var init_AuthService = __esm({
   "packages/cli/src/services/AuthService.ts"() {
@@ -222524,18 +223604,20 @@ var init_AuthService = __esm({
     readlineSync = __toESM(require_readline_sync(), 1);
     AuthService = class {
       userJsonPath;
+      keysJsonPath;
       authApiUrl;
       mpdaiConfig;
       constructor(authApiUrl) {
         this.mpdaiConfig = MpdaiConfigManager.getInstance();
         this.authApiUrl = authApiUrl || this.mpdaiConfig.getAuthUrl();
-        this.userJsonPath = join16(homedir11(), ".gemini", "user.json");
+        this.userJsonPath = join17(homedir12(), ".mpdai", "user.json");
+        this.keysJsonPath = join17(homedir12(), ".mpdai", "keys.json");
       }
       /**
        * 检查本地是否存在用户凭据文件
        */
       hasLocalCredentials() {
-        return existsSync11(this.userJsonPath);
+        return existsSync12(this.userJsonPath);
       }
       /**
        * 从本地文件读取用户凭据
@@ -222545,7 +223627,7 @@ var init_AuthService = __esm({
           if (!this.hasLocalCredentials()) {
             return null;
           }
-          const content = readFileSync10(this.userJsonPath, "utf-8");
+          const content = readFileSync11(this.userJsonPath, "utf-8");
           const credentials = JSON.parse(content);
           if (credentials.encodedPassword) {
             credentials.password = Buffer.from(credentials.encodedPassword, "base64").toString("utf-8");
@@ -222562,8 +223644,8 @@ var init_AuthService = __esm({
        */
       saveCredentials(credentials) {
         try {
-          const dir = join16(homedir11(), ".gemini");
-          if (!existsSync11(dir)) {
+          const dir = join17(homedir12(), ".mpdai");
+          if (!existsSync12(dir)) {
             mkdirSync4(dir, { recursive: true });
           }
           const credentialsToSave = {
@@ -222576,6 +223658,43 @@ var init_AuthService = __esm({
           throw error;
         }
       }
+      /**
+       * 检查本地是否存在 keys 文件
+       */
+      hasLocalKeys() {
+        return existsSync12(this.keysJsonPath);
+      }
+      /**
+       * 从本地文件读取 keys
+       */
+      getLocalKeys() {
+        try {
+          if (!this.hasLocalKeys()) {
+            return null;
+          }
+          const content = readFileSync11(this.keysJsonPath, "utf-8");
+          const keys = JSON.parse(content);
+          return keys;
+        } catch (error) {
+          console.error("Failed to read keys:", error);
+          return null;
+        }
+      }
+      /**
+       * 保存 keys 到本地文件
+       */
+      saveKeys(keys) {
+        try {
+          const dir = join17(homedir12(), ".mpdai");
+          if (!existsSync12(dir)) {
+            mkdirSync4(dir, { recursive: true });
+          }
+          writeFileSync4(this.keysJsonPath, JSON.stringify(keys, null, 2), "utf-8");
+        } catch (error) {
+          console.error("Failed to save keys:", error);
+          throw error;
+        }
+      }
       /**
        * 调用认证接口获取用户数据
        */
@@ -222675,6 +223794,12 @@ var init_AuthService = __esm({
         if (!this.hasLocalCredentials()) {
           this.saveCredentials(credentials);
         }
+        if (authResponse.keys && authResponse.keys.length > 0) {
+          this.saveKeys(authResponse.keys);
+          if (isDebugMode) {
+            console.log(`Saved ${authResponse.keys.length} keys to local storage`);
+          }
+        }
         return authResponse;
       }
       /**
@@ -231670,7 +232795,7 @@ var require_require_directory = __commonJS({
   "node_modules/require-directory/index.js"(exports2, module2) {
     "use strict";
     var fs51 = __require("fs");
-    var join24 = __require("path").join;
+    var join25 = __require("path").join;
     var resolve18 = __require("path").resolve;
     var dirname11 = __require("path").dirname;
     var defaultOptions2 = {
@@ -231707,7 +232832,7 @@ var require_require_directory = __commonJS({
       }
       path53 = !path53 ? dirname11(m.filename) : resolve18(dirname11(m.filename), path53);
       fs51.readdirSync(path53).forEach(function(filename) {
-        var joined = join24(path53, filename), files, key, obj;
+        var joined = join25(path53, filename), files, key, obj;
         if (fs51.statSync(joined).isDirectory() && options.recurse) {
           files = requireDirectory(m, joined, options);
           if (Object.keys(files).length) {
@@ -235477,7 +236602,7 @@ var require_minimist = __commonJS({
 var require_rc = __commonJS({
   "node_modules/rc/index.js"(exports2, module2) {
     var cc = require_utils13();
-    var join24 = __require("path").join;
+    var join25 = __require("path").join;
     var deepExtend = require_deep_extend();
     var etc = "/etc";
     var win = process.platform === "win32";
@@ -235502,15 +236627,15 @@ var require_rc = __commonJS({
       }
       if (!win)
         [
-          join24(etc, name2, "config"),
-          join24(etc, name2 + "rc")
+          join25(etc, name2, "config"),
+          join25(etc, name2 + "rc")
         ].forEach(addConfigFile);
       if (home)
         [
-          join24(home, ".config", name2, "config"),
-          join24(home, ".config", name2),
-          join24(home, "." + name2, "config"),
-          join24(home, "." + name2 + "rc")
+          join25(home, ".config", name2, "config"),
+          join25(home, ".config", name2),
+          join25(home, "." + name2, "config"),
+          join25(home, "." + name2 + "rc")
         ].forEach(addConfigFile);
       addConfigFile(cc.find("." + name2 + "rc"));
       if (env6.config) addConfigFile(env6.config);
@@ -251824,7 +252949,7 @@ import { promises as fs33 } from "fs";
 import path37 from "path";
 
 // packages/cli/src/generated/git-commit.ts
-var GIT_COMMIT_INFO = "220545e (local modifications)";
+var GIT_COMMIT_INFO = "cc090d6";
 
 // node_modules/read-package-up/index.js
 import path35 from "node:path";
@@ -252037,7 +253162,7 @@ async function getPackageJson() {
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.1.25";
+  return "0.1.31";
 }
 
 // packages/cli/src/ui/commands/memoryCommand.ts
@@ -252134,7 +253259,7 @@ ${memoryContent}
 var helpCommand = {
   name: "help",
   altName: "?",
-  description: "for help on gemini-cli",
+  description: "for help on mpdai-cli",
   action: (_context, _args) => {
     console.debug("Opening help UI ...");
     return {
@@ -252156,9 +253281,9 @@ var clearCommand = {
 };
 
 // packages/cli/src/ui/commands/logoutCommand.ts
-import { existsSync as existsSync8, unlinkSync } from "fs";
-import { join as join13 } from "path";
-import { homedir as homedir8 } from "os";
+import { existsSync as existsSync9, unlinkSync } from "fs";
+import { join as join14 } from "path";
+import { homedir as homedir9 } from "os";
 var logoutCommand = {
   name: "logout",
   description: "logout and clear user credentials and settings, then exit",
@@ -252166,8 +253291,8 @@ var logoutCommand = {
     const now = /* @__PURE__ */ new Date();
     const { sessionStartTime } = context2.session.stats;
     const wallDuration = now.getTime() - sessionStartTime.getTime();
-    const userJsonPath = join13(homedir8(), ".gemini", "user.json");
-    if (existsSync8(userJsonPath)) {
+    const userJsonPath = join14(homedir9(), ".mpdai", "user.json");
+    if (existsSync9(userJsonPath)) {
       try {
         unlinkSync(userJsonPath);
         context2.ui.addItem({
@@ -252181,8 +253306,23 @@ var logoutCommand = {
         }, now.getTime());
       }
     }
-    const userSettingsPath = join13(homedir8(), ".gemini", "settings.json");
-    if (existsSync8(userSettingsPath)) {
+    const keysJsonPath = join14(homedir9(), ".mpdai", "keys.json");
+    if (existsSync9(keysJsonPath)) {
+      try {
+        unlinkSync(keysJsonPath);
+        context2.ui.addItem({
+          type: "info" /* INFO */,
+          text: "\u2705 Keys cleared"
+        }, now.getTime());
+      } catch (error) {
+        context2.ui.addItem({
+          type: "error" /* ERROR */,
+          text: `\u274C Failed to clear keys: ${error}`
+        }, now.getTime());
+      }
+    }
+    const userSettingsPath = join14(homedir9(), ".mpdai", "settings.json");
+    if (existsSync9(userSettingsPath)) {
       try {
         unlinkSync(userSettingsPath);
         context2.ui.addItem({
@@ -252267,13 +253407,144 @@ var modelCommand = {
   }
 };
 
+// packages/cli/src/ui/commands/routerCommand.ts
+import { run as runRouter } from "@mpdai/router";
+import { showStatus, executeCodeCommand, runModelSelector } from "@mpdai/router";
+import { isServiceRunning, cleanupPidFile } from "@mpdai/router";
+import { PID_FILE, REFERENCE_COUNT_FILE } from "@mpdai/router";
+import { readFileSync as readFileSync12, existsSync as existsSync13, unlinkSync as unlinkSync2 } from "fs";
+async function waitForService(timeout2 = 1e4, initialDelay = 1e3) {
+  await new Promise((resolve18) => setTimeout(resolve18, initialDelay));
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout2) {
+    const isRunning = await isServiceRunning();
+    if (isRunning) {
+      await new Promise((resolve18) => setTimeout(resolve18, 500));
+      return true;
+    }
+    await new Promise((resolve18) => setTimeout(resolve18, 100));
+  }
+  return false;
+}
+async function handleRouterStart() {
+  await runRouter();
+}
+async function handleRouterStop() {
+  try {
+    const pid = parseInt(readFileSync12(PID_FILE, "utf-8"));
+    process.kill(pid);
+    cleanupPidFile();
+    if (existsSync13(REFERENCE_COUNT_FILE)) {
+      try {
+        unlinkSync2(REFERENCE_COUNT_FILE);
+      } catch (e2) {
+      }
+    }
+    console.log("MPD AI router service has been successfully stopped.");
+  } catch (e2) {
+    console.log("Failed to stop the service. It may have already been stopped.");
+    cleanupPidFile();
+  }
+}
+async function handleRouterRestart() {
+  try {
+    const pid = parseInt(readFileSync12(PID_FILE, "utf-8"));
+    process.kill(pid);
+    cleanupPidFile();
+    if (existsSync13(REFERENCE_COUNT_FILE)) {
+      try {
+        unlinkSync2(REFERENCE_COUNT_FILE);
+      } catch (e2) {
+      }
+    }
+    console.log("MPD AI router service has been stopped.");
+  } catch (e2) {
+    console.log("Service was not running or failed to stop.");
+    cleanupPidFile();
+  }
+  console.log("Starting MPD AI router service...");
+  await runRouter();
+}
+async function handleRouterStatus() {
+  await showStatus();
+}
+async function handleRouterCode(args) {
+  const isRunning = await isServiceRunning();
+  if (!isRunning) {
+    console.log("Service not running, starting service...");
+    await runRouter();
+    if (await waitForService()) {
+      const codeArgs = args ? args.split(" ") : [];
+      executeCodeCommand(codeArgs);
+    } else {
+      console.error("Service startup timeout, please manually run `mpdai router start` to start the service");
+      process.exit(1);
+    }
+  } else {
+    const codeArgs = args ? args.split(" ") : [];
+    executeCodeCommand(codeArgs);
+  }
+}
+async function handleRouterModel() {
+  await runModelSelector();
+}
+var routerCommand = {
+  name: "router",
+  description: "Router commands for managing the MPD AI router service",
+  subCommands: [
+    {
+      name: "start",
+      description: "Start the router service",
+      action: async (_context, _args) => {
+        await handleRouterStart();
+      }
+    },
+    {
+      name: "stop",
+      description: "Stop the router service",
+      action: async (_context, _args) => {
+        await handleRouterStop();
+      }
+    },
+    {
+      name: "restart",
+      description: "Restart the router service",
+      action: async (_context, _args) => {
+        await handleRouterRestart();
+      }
+    },
+    {
+      name: "status",
+      description: "Show router service status",
+      action: async (_context, _args) => {
+        await handleRouterStatus();
+      }
+    },
+    {
+      name: "code",
+      description: "Execute Claude Code command",
+      action: async (_context, args) => {
+        await handleRouterCode(args);
+      }
+    },
+    {
+      name: "model",
+      description: "Interactive model selection and configuration",
+      action: async (_context, _args) => {
+        await handleRouterModel();
+      }
+    }
+  ]
+};
+
 // packages/cli/src/services/CommandService.ts
 var loadBuiltInCommands = async () => [
   clearCommand,
   helpCommand,
   memoryCommand,
   logoutCommand,
-  modelCommand
+  modelCommand,
+  routerCommand
 ];
 var CommandService = class {
   constructor(commandLoader = loadBuiltInCommands) {
@@ -252416,9 +253687,9 @@ var useSlashCommandProcessor = (config2, settings, history, addItem, clearItems,
       // `/help` and `/clear` have been migrated and REMOVED from this list.
       {
         name: "docs",
-        description: "open full Gemini CLI documentation in your browser",
+        description: "open full MPD AI CLI documentation in your browser",
         action: async (_mainCommand, _subCommand, _args) => {
-          const docsUrl = "https://goo.gle/gemini-cli-docs";
+          const docsUrl = "http://lb-100-123-141-85.lbaas.jpe2f.dcnw.rakuten/management/docs/";
           if (process25.env.SANDBOX && process25.env.SANDBOX !== "sandbox-exec") {
             addMessage({
               type: "info" /* INFO */,
@@ -252516,7 +253787,7 @@ ${docsUrl}`,
           const mcpServers = config2?.getMcpServers() || {};
           const serverNames = Object.keys(mcpServers);
           if (serverNames.length === 0) {
-            const docsUrl = "https://goo.gle/gemini-cli-docs-mcp";
+            const docsUrl = "http://lb-100-123-141-85.lbaas.jpe2f.dcnw.rakuten/management/docs/tools/mcp-server.html";
             if (process25.env.SANDBOX && process25.env.SANDBOX !== "sandbox-exec") {
               addMessage({
                 type: "info" /* INFO */,
@@ -253076,7 +254347,7 @@ ${bugReportUrl}`,
           if (!checkpointDir) {
             addMessage({
               type: "error" /* ERROR */,
-              content: "Could not determine the .gemini directory path.",
+              content: "Could not determine the .mpdai directory path.",
               timestamp: /* @__PURE__ */ new Date()
             });
             return;
@@ -269438,9 +270709,9 @@ init_dist3();
 var import_strip_json_comments = __toESM(require_strip_json_comments(), 1);
 import * as fs36 from "fs";
 import * as path40 from "path";
-import { homedir as homedir12 } from "os";
-var SETTINGS_DIRECTORY_NAME = ".gemini";
-var USER_SETTINGS_DIR = path40.join(homedir12(), SETTINGS_DIRECTORY_NAME);
+import { homedir as homedir13 } from "os";
+var SETTINGS_DIRECTORY_NAME = ".mpdai";
+var USER_SETTINGS_DIR = path40.join(homedir13(), SETTINGS_DIRECTORY_NAME);
 var USER_SETTINGS_PATH = path40.join(USER_SETTINGS_DIR, "settings.json");
 var LoadedSettings = class {
   constructor(user, workspace, errors) {
@@ -269513,7 +270784,7 @@ function resolveEnvVarsInObject(obj) {
 function findEnvFile(startDir) {
   let currentDir = path40.resolve(startDir);
   while (true) {
-    const geminiEnvPath = path40.join(currentDir, GEMINI_CONFIG_DIR, ".env");
+    const geminiEnvPath = path40.join(currentDir, MPDAI_CONFIG_DIR, ".env");
     if (fs36.existsSync(geminiEnvPath)) {
       return geminiEnvPath;
     }
@@ -269523,11 +270794,11 @@ function findEnvFile(startDir) {
     }
     const parentDir = path40.dirname(currentDir);
     if (parentDir === currentDir || !parentDir) {
-      const homeGeminiEnvPath = path40.join(homedir12(), GEMINI_CONFIG_DIR, ".env");
+      const homeGeminiEnvPath = path40.join(homedir13(), MPDAI_CONFIG_DIR, ".env");
       if (fs36.existsSync(homeGeminiEnvPath)) {
         return homeGeminiEnvPath;
       }
-      const homeEnvPath = path40.join(homedir12(), ".env");
+      const homeEnvPath = path40.join(homedir13(), ".env");
       if (fs36.existsSync(homeEnvPath)) {
         return homeEnvPath;
       }
@@ -271313,7 +272584,7 @@ function stripQuotes(val) {
 }
 
 // node_modules/yargs-parser/build/lib/index.js
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 var _a5;
 var _b;
 var _c;
@@ -271340,7 +272611,7 @@ var parser4 = new YargsParser({
     if (typeof __require !== "undefined") {
       return __require(path53);
     } else if (path53.match(/\.json$/)) {
-      return JSON.parse(readFileSync12(path53, "utf8"));
+      return JSON.parse(readFileSync14(path53, "utf8"));
     } else {
       throw Error("only .json config files are supported in ESM");
     }
@@ -271668,17 +272939,17 @@ function sync_default(start, callback) {
 
 // node_modules/yargs/lib/platform-shims/esm.mjs
 import { inspect } from "util";
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync16 } from "fs";
 import { fileURLToPath as fileURLToPath7 } from "url";
 import { basename as basename4, dirname as dirname10, extname as extname2, relative as relative6, resolve as resolve17 } from "path";
 
 // node_modules/y18n/build/lib/platform-shims/node.js
-import { readFileSync as readFileSync13, statSync as statSync3, writeFile as writeFile5 } from "fs";
+import { readFileSync as readFileSync15, statSync as statSync3, writeFile as writeFile5 } from "fs";
 import { format as format2 } from "util";
 import { resolve as resolve16 } from "path";
 var node_default = {
   fs: {
-    readFileSync: readFileSync13,
+    readFileSync: readFileSync15,
     writeFile: writeFile5
   },
   format: format2,
@@ -271902,7 +273173,7 @@ var esm_default3 = {
     nextTick: process.nextTick,
     stdColumns: typeof process.stdout.columns !== "undefined" ? process.stdout.columns : null
   },
-  readFileSync: readFileSync14,
+  readFileSync: readFileSync16,
   require: () => {
     throw new YError(REQUIRE_ERROR);
   },
@@ -271926,7 +273197,7 @@ import process29 from "node:process";
 import * as fs37 from "fs";
 import * as path41 from "path";
 import * as os11 from "os";
-var EXTENSIONS_DIRECTORY_NAME = path41.join(".gemini", "extensions");
+var EXTENSIONS_DIRECTORY_NAME = path41.join(".mpdai", "extensions");
 var EXTENSIONS_CONFIG_FILENAME = "gemini-extension.json";
 function loadExtensions(workspaceDir) {
   const allExtensions = [
@@ -273120,7 +274391,7 @@ init_dist3();
 init_langfuseClient();
 import { execSync as execSync2 } from "child_process";
 import { promises as fs38 } from "fs";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 var DataCollector = class {
   langfuseClient;
   constructor() {
@@ -273230,7 +274501,7 @@ var DataCollector = class {
   // 提取元数据
   extractMetadata(data) {
     return {
-      cli_version: "0.1.25",
+      cli_version: "0.1.31",
       model: process.env.CUSTOM_LLM_MODEL_NAME || "gemini",
       auth_type: process.env.USE_CUSTOM_LLM ? "custom_llm" : "google_oauth",
       project_path: data.projectPath,
@@ -273447,7 +274718,7 @@ var DataCollector = class {
       const walkDir = async (dir) => {
         const entries = await fs38.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = join21(dir, entry.name);
+          const fullPath = join22(dir, entry.name);
           if (entry.isDirectory()) {
             dirCount++;
             await walkDir(fullPath);
@@ -273650,7 +274921,7 @@ var ToolConfirmationMessage = ({
     }
   };
   let bodyContent = null;
-  let question2;
+  let question3;
   const options = new Array();
   function availableBodyContentHeight() {
     if (options.length === 0) {
@@ -273685,7 +274956,7 @@ var ToolConfirmationMessage = ({
         }
       );
     }
-    question2 = `Apply this change?`;
+    question3 = `Apply this change?`;
     options.push(
       {
         label: "Yes, allow once",
@@ -273712,7 +274983,7 @@ var ToolConfirmationMessage = ({
     );
   } else if (confirmationDetails.type === "exec") {
     const executionProps = confirmationDetails;
-    question2 = `Allow execution?`;
+    question3 = `Allow execution?`;
     options.push(
       {
         label: "Yes, allow once",
@@ -273739,7 +275010,7 @@ var ToolConfirmationMessage = ({
   } else if (confirmationDetails.type === "info") {
     const infoProps = confirmationDetails;
     const displayUrls = infoProps.urls && !(infoProps.urls.length === 1 && infoProps.urls[0] === infoProps.prompt);
-    question2 = `Do you want to proceed?`;
+    question3 = `Do you want to proceed?`;
     options.push(
       {
         label: "Yes, allow once",
@@ -273777,7 +275048,7 @@ var ToolConfirmationMessage = ({
         /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(Box_default, { marginLeft: 1, children: /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(Text, { color: Colors.Gray, children: mcpProps.args ? JSON.stringify(mcpProps.args, null, 2) : "No parameters" }) })
       ] })
     ] });
-    question2 = `Allow execution of MCP tool "${mcpProps.toolName}" from server "${mcpProps.serverName}"?`;
+    question3 = `Allow execution of MCP tool "${mcpProps.toolName}" from server "${mcpProps.serverName}"?`;
     options.push(
       {
         label: "Yes, allow once",
@@ -273797,7 +275068,7 @@ var ToolConfirmationMessage = ({
   }
   return /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)(Box_default, { flexDirection: "column", padding: 1, width: childWidth, children: [
     /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(Box_default, { flexGrow: 1, flexShrink: 1, overflow: "hidden", marginBottom: 1, children: bodyContent }),
-    /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(Box_default, { marginBottom: 1, flexShrink: 0, children: /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(Text, { wrap: "truncate", children: question2 }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(Box_default, { marginBottom: 1, flexShrink: 0, children: /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(Text, { wrap: "truncate", children: question3 }) }),
     /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(Box_default, { flexShrink: 0, children: /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(
       RadioButtonSelect,
       {
@@ -273949,7 +275220,7 @@ var AboutBox = ({
     marginY: 1,
     width: "100%",
     children: [
-      /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(Box_default, { marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(Text, { bold: true, color: Colors.AccentPurple, children: "About Gemini CLI" }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(Box_default, { marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(Text, { bold: true, color: Colors.AccentPurple, children: "About MPDAI CLI" }) }),
       /* @__PURE__ */ (0, import_jsx_runtime38.jsxs)(Box_default, { flexDirection: "row", children: [
         /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(Box_default, { width: "35%", children: /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(Text, { bold: true, color: Colors.LightBlue, children: "CLI Version" }) }),
         /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(Box_default, { children: /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(Text, { children: cliVersion }) })
@@ -278661,7 +279932,7 @@ async function checkForUpdates() {
       shouldNotifyInNpmScript: true
     });
     if (notifier.update && import_semver3.default.gt(notifier.update.latest, notifier.update.current)) {
-      return null;
+      return `A new version is available: ${notifier.update.current} \u2192 ${notifier.update.latest}`;
     }
     return null;
   } catch (e2) {
@@ -279181,8 +280452,8 @@ var App2 = ({ config: config2, settings, startupWarnings = [] }) => {
         {
           type: "info" /* INFO */,
           text: `\u26A1 Slow response times detected. Automatically switching from ${currentModel2} to ${fallbackModel} for faster responses for the remainder of this session.
-\u26A1 To avoid this you can either upgrade to Standard tier. See: https://goo.gle/set-up-gemini-code-assist
-\u26A1 Or you can utilize a Gemini API Key. See: https://goo.gle/gemini-cli-docs-auth#gemini-api-key
+\u26A1 To avoid this you can either upgrade to Standard tier. See: http://lb-100-123-141-85.lbaas.jpe2f.dcnw.rakuten/mpdaicli.html
+\u26A1 Or you can utilize a MPD API Key. See: http://lb-100-123-141-85.lbaas.jpe2f.dcnw.rakuten/management
 \u26A1 You can switch authentication methods by typing /auth`
         },
         Date.now()
@@ -280367,7 +281638,7 @@ var homeDirectoryCheck = {
         fs48.realpath(os21.homedir())
       ]);
       if (workspaceRealPath === homeRealPath) {
-        return "You are running Gemini CLI in your home directory. It is recommended to run in a project-specific directory.";
+        return "You are running MPD AI CLI in your home directory. It is recommended to run in a project-specific directory.";
       }
       return null;
     } catch (_err) {
@@ -280497,10 +281768,10 @@ async function runNonInteractive(config2, input) {
 // packages/cli/src/utils/cleanup.ts
 init_dist3();
 import { promises as fs49 } from "fs";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 async function cleanupCheckpoints() {
   const tempDir = getProjectTempDir(process.cwd());
-  const checkpointsDir = join22(tempDir, "checkpoints");
+  const checkpointsDir = join23(tempDir, "checkpoints");
   try {
     await fs49.rm(checkpointsDir, { recursive: true, force: true });
   } catch {
@@ -280515,24 +281786,24 @@ init_EnvConfigManager();
 init_mpdaiConfig();
 import * as fs50 from "fs";
 import * as path52 from "path";
-import { homedir as homedir15 } from "os";
+import { homedir as homedir16 } from "os";
 function initializeLangfuseConfig() {
-  const langfuseDir = path52.join(homedir15(), ".gemini");
+  const langfuseDir = path52.join(homedir16(), ".mpdai");
   const settingsFile = path52.join(langfuseDir, "settings.conf");
   const isDebugMode = process.env.DEBUG === "true" || process.env.DEBUG_MODE === "true" || process.env.dev === "true";
   try {
     if (!fs50.existsSync(langfuseDir)) {
       if (isDebugMode) {
-        console.log("\u{1F4C1} Creating .gemini directory...");
+        console.log("\u{1F4C1} Creating .mpdai directory...");
       }
       fs50.mkdirSync(langfuseDir, { recursive: true });
       if (isDebugMode) {
-        console.log("\u2705 .gemini directory created successfully");
+        console.log("\u2705 .mpdai directory created successfully");
       }
     }
     if (!fs50.existsSync(settingsFile)) {
       if (isDebugMode) {
-        console.log("\u{1F4DD} Creating .gemini/settings.conf...");
+        console.log("\u{1F4DD} Creating .mpdai/settings.conf...");
       }
       const defaultSettings = {
         "secretKey": "sk-lf-9da9fdd0-2198-41e6-a1fc-f1abeb08ddff",
@@ -280543,11 +281814,11 @@ function initializeLangfuseConfig() {
       };
       fs50.writeFileSync(settingsFile, JSON.stringify(defaultSettings, null, 2));
       if (isDebugMode) {
-        console.log("\u2705 .gemini/settings.conf created successfully");
+        console.log("\u2705 .mpdai/settings.conf created successfully");
       }
     } else {
       if (isDebugMode) {
-        console.log("\u2705 .gemini/settings.conf already exists");
+        console.log("\u2705 .mpdai/settings.conf already exists");
       }
     }
   } catch (error) {
@@ -280592,7 +281863,121 @@ function loadStartupConfig() {
 
 // packages/cli/src/gemini.tsx
 init_dist3();
+
+// packages/cli/src/routerCli.ts
+import { run as runRouter2 } from "@mpdai/router";
+import { showStatus as showStatus2, executeCodeCommand as executeCodeCommand2, runModelSelector as runModelSelector2 } from "@mpdai/router";
+import { isServiceRunning as isServiceRunning2, cleanupPidFile as cleanupPidFile2 } from "@mpdai/router";
+import { PID_FILE as PID_FILE2, REFERENCE_COUNT_FILE as REFERENCE_COUNT_FILE2 } from "@mpdai/router";
+import { readFileSync as readFileSync18, existsSync as existsSync18, unlinkSync as unlinkSync3 } from "fs";
+async function waitForService2(timeout2 = 1e4, initialDelay = 1e3) {
+  await new Promise((resolve18) => setTimeout(resolve18, initialDelay));
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout2) {
+    const isRunning = await isServiceRunning2();
+    if (isRunning) {
+      await new Promise((resolve18) => setTimeout(resolve18, 500));
+      return true;
+    }
+    await new Promise((resolve18) => setTimeout(resolve18, 100));
+  }
+  return false;
+}
+async function handleRouterCommand(command, args) {
+  if (command !== "router") {
+    return false;
+  }
+  const subCommand = args[0];
+  const isRunning = await isServiceRunning2();
+  switch (subCommand) {
+    case "start":
+      await runRouter2();
+      return true;
+    case "stop":
+      try {
+        const pid = parseInt(readFileSync18(PID_FILE2, "utf-8"));
+        process.kill(pid);
+        cleanupPidFile2();
+        if (existsSync18(REFERENCE_COUNT_FILE2)) {
+          try {
+            unlinkSync3(REFERENCE_COUNT_FILE2);
+          } catch (e2) {
+          }
+        }
+        console.log("MPD AI router service has been successfully stopped.");
+      } catch (e2) {
+        console.log("Failed to stop the service. It may have already been stopped.");
+        cleanupPidFile2();
+      }
+      return true;
+    case "restart":
+      try {
+        const pid = parseInt(readFileSync18(PID_FILE2, "utf-8"));
+        process.kill(pid);
+        cleanupPidFile2();
+        if (existsSync18(REFERENCE_COUNT_FILE2)) {
+          try {
+            unlinkSync3(REFERENCE_COUNT_FILE2);
+          } catch (e2) {
+          }
+        }
+        console.log("MPD AI router service has been stopped.");
+      } catch (e2) {
+        console.log("Service was not running or failed to stop.");
+        cleanupPidFile2();
+      }
+      console.log("Starting MPD AI router service...");
+      await runRouter2();
+      return true;
+    case "status":
+      await showStatus2();
+      return true;
+    case "code":
+      if (!isRunning) {
+        console.log("Service not running, starting service...");
+        await runRouter2();
+        if (await waitForService2()) {
+          const codeArgs = args.slice(1);
+          executeCodeCommand2(codeArgs);
+        } else {
+          console.error("Service startup timeout, please manually run `mpdai router start` to start the service");
+          process.exit(1);
+        }
+      } else {
+        const codeArgs = args.slice(1);
+        executeCodeCommand2(codeArgs);
+      }
+      return true;
+    case "model":
+      await runModelSelector2();
+      return true;
+    default:
+      console.log(`
+Usage: mpdai router [command]
+
+Commands:
+  start         Start server 
+  stop          Stop server
+  restart       Restart server
+  status        Show server status
+  code          Execute claude command
+  model         Interactive model selection and configuration
+
+Example:
+  mpdai router start
+  mpdai router code "Write a Hello World"
+  mpdai router model
+`);
+      return true;
+  }
+}
+
+// packages/cli/src/gemini.tsx
+var readlineSync2 = __toESM(require_readline_sync(), 1);
 var import_jsx_runtime52 = __toESM(require_jsx_runtime(), 1);
+import { executeCodeCommand as executeCodeCommand3 } from "@mpdai/router";
+import { isServiceRunning as isServiceRunning3 } from "@mpdai/router";
+import { run as runRouter3 } from "@mpdai/router";
 function getNodeMemoryArgs(config2) {
   const totalMemoryMB = os22.totalmem() / (1024 * 1024);
   const heapStats = v8.getHeapStatistics();
@@ -280628,7 +282013,110 @@ async function relaunchWithAdditionalArgs(additionalArgs) {
   await new Promise((resolve18) => child.on("close", resolve18));
   process.exit(0);
 }
+async function waitForService3(timeout2 = 1e4, initialDelay = 1e3) {
+  await new Promise((resolve18) => setTimeout(resolve18, initialDelay));
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout2) {
+    const isRunning = await isServiceRunning3();
+    if (isRunning) {
+      await new Promise((resolve18) => setTimeout(resolve18, 500));
+      return true;
+    }
+    await new Promise((resolve18) => setTimeout(resolve18, 100));
+  }
+  return false;
+}
+async function installClaudeCode() {
+  return new Promise((resolve18) => {
+    console.log("Installing @anthropic-ai/claude-code@2.0.35...");
+    const installProcess = spawn10("npm", ["install", "-g", "@anthropic-ai/claude-code@2.0.35"], {
+      stdio: "inherit",
+      shell: true
+    });
+    installProcess.on("close", (code) => {
+      if (code === 0) {
+        console.log("\u2705 Claude Code installed successfully!");
+        resolve18(true);
+      } else {
+        console.error("\u274C Failed to install Claude Code");
+        resolve18(false);
+      }
+    });
+    installProcess.on("error", (error) => {
+      console.error("\u274C Error installing Claude Code:", error.message);
+      resolve18(false);
+    });
+  });
+}
+async function handleClaudeCodeCommand(args) {
+  const isRunning = await isServiceRunning3();
+  if (!isRunning) {
+    console.log("Service not running, starting service...");
+    runRouter3();
+    if (!await waitForService3()) {
+      console.error("Service startup timeout, please manually run `mpdai router start` to start the service");
+      process.exit(1);
+    }
+  }
+  try {
+    const executeWithErrorHandling = () => {
+      return new Promise((resolve18, reject) => {
+        const checkProcess = spawn10("claude", ["--version"], {
+          stdio: "pipe",
+          shell: true
+        });
+        checkProcess.on("error", async (error) => {
+          console.error("\u274C Claude Code is not installed or not found in PATH");
+          console.log("\nTo install Claude Code, run:");
+          console.log("  npm install -g @anthropic-ai/claude-code@2.0.35\n");
+          if (process.stdin.isTTY && process.stdout.isTTY) {
+            const answer = readlineSync2.question("Would you like to install it now? (y/n): ");
+            const shouldInstall = answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+            if (shouldInstall) {
+              const installed = await installClaudeCode();
+              if (installed) {
+                executeCodeCommand3(args);
+                resolve18();
+              } else {
+                reject(new Error("Installation failed"));
+              }
+            } else {
+              reject(new Error("User declined installation"));
+            }
+          } else {
+            reject(new Error("Claude Code not found and cannot install in non-interactive mode"));
+          }
+        });
+        checkProcess.on("close", (code) => {
+          if (code === 0) {
+            executeCodeCommand3(args);
+            resolve18();
+          } else {
+            executeCodeCommand3(args);
+            resolve18();
+          }
+        });
+      });
+    };
+    await executeWithErrorHandling();
+  } catch (error) {
+    console.error("Failed to execute Claude Code command:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+  return true;
+}
 async function main() {
+  const args = process.argv.slice(2);
+  if (args.length > 0 && args[0] === "router") {
+    const handled = await handleRouterCommand("router", args.slice(1));
+    if (handled) {
+      return;
+    }
+  }
+  if (args.length > 0 && args[0] === "claude" && args.length > 1 && args[1] === "code") {
+    await handleClaudeCodeCommand(args.slice(2));
+    return;
+  }
   loadStartupConfig();
   const workspaceRoot = process.cwd();
   let settings = loadSettings(workspaceRoot);
@@ -280839,6 +282327,17 @@ async function performUserAuthentication() {
     if (isDebugMode) {
       console.log(`Environment configuration updated: ${envPath}`);
     }
+    try {
+      const { updateRouterConfigFromModel } = await import("@mpdai/router");
+      await updateRouterConfigFromModel(defaultModel);
+      if (isDebugMode) {
+        console.log("Router configuration updated with default model");
+      }
+    } catch (error) {
+      if (isDebugMode) {
+        console.warn("Failed to update router-config.json:", error.message);
+      }
+    }
     if (authResponse.mcpServers && authResponse.mcpServers.length > 0) {
       if (isDebugMode) {
         console.log(`Found ${authResponse.mcpServers.length} MCP servers in user configuration`);