@iflow-mcp/camoneart-maestro 5.0.0

package/dist/mcp/server.js

@@ -0,0 +1,847 @@
+#!/usr/bin/env node
+
+// src/mcp/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { z as z2 } from "zod";
+
+// src/core/git.ts
+import simpleGit from "simple-git";
+
+// src/core/config.ts
+import { z } from "zod";
+import Conf from "conf";
+import path from "path";
+import fs from "fs/promises";
+var ConfigSchema = z.object({
+  // Git worktree設定
+  worktrees: z.object({
+    // worktreeを作成するディレクトリ（デフォルト: .git/orchestrations）
+    path: z.string().optional(),
+    // ブランチ名のプレフィックス
+    branchPrefix: z.string().optional(),
+    // ディレクトリ名のプレフィックス（デフォルト: 空文字列）
+    directoryPrefix: z.string().optional()
+  }).optional(),
+  // 開発環境設定
+  development: z.object({
+    // 自動でnpm installを実行
+    autoSetup: z.boolean().default(true),
+    // 同期するファイル（.envなど）
+    syncFiles: z.array(z.string()).default([".env", ".env.local"]),
+    // デフォルトのエディタ
+    defaultEditor: z.enum(["vscode", "cursor", "none"]).default("cursor")
+  }).optional(),
+  // tmux統合設定
+  tmux: z.object({
+    enabled: z.boolean().default(false),
+    // 新規ウィンドウかペインか
+    openIn: z.enum(["window", "pane"]).default("window"),
+    // セッション名の命名規則
+    sessionNaming: z.string().default("{branch}")
+  }).optional(),
+  // Claude Code統合設定
+  claude: z.object({
+    // CLAUDE.mdの処理方法
+    markdownMode: z.enum(["shared", "split"]).default("shared")
+  }).optional(),
+  // GitHub統合設定
+  github: z.object({
+    // 自動でfetchを実行
+    autoFetch: z.boolean().default(true),
+    // ブランチ命名規則
+    branchNaming: z.object({
+      // PR用のテンプレート (例: "pr-{number}-{title}")
+      prTemplate: z.string().default("pr-{number}"),
+      // Issue用のテンプレート (例: "issue-{number}-{title}")
+      issueTemplate: z.string().default("issue-{number}")
+    }).optional()
+  }).optional(),
+  // UI表示設定
+  ui: z.object({
+    // パス表示形式 ('absolute' | 'relative')
+    pathDisplay: z.enum(["absolute", "relative"]).default("absolute")
+  }).optional(),
+  // カスタムコマンドとファイルコピー設定
+  hooks: z.object({
+    // worktree作成後に実行（文字列または配列）
+    afterCreate: z.union([z.string(), z.array(z.string())]).optional(),
+    // worktree削除前に実行
+    beforeDelete: z.string().optional()
+  }).optional(),
+  // worktree作成時の処理
+  postCreate: z.object({
+    // コピーするファイル（gitignoreファイルも含む）
+    copyFiles: z.array(z.string()).optional(),
+    // 実行するコマンド
+    commands: z.array(z.string()).optional()
+  }).optional()
+});
+var DEFAULT_CONFIG = {
+  worktrees: {
+    path: "../maestro-{branch}",
+    directoryPrefix: ""
+  },
+  development: {
+    autoSetup: true,
+    syncFiles: [".env", ".env.local"],
+    defaultEditor: "cursor"
+  },
+  tmux: {
+    enabled: false,
+    openIn: "window",
+    sessionNaming: "{branch}"
+  },
+  claude: {
+    markdownMode: "shared"
+  },
+  github: {
+    autoFetch: true
+  },
+  ui: {
+    pathDisplay: "absolute"
+  },
+  hooks: {}
+};
+var ConfigManager = class {
+  conf;
+  projectConfig = null;
+  userConfig = null;
+  constructor() {
+    this.conf = new Conf({
+      projectName: "maestro",
+      defaults: DEFAULT_CONFIG
+    });
+  }
+  async loadProjectConfig() {
+    try {
+      await this.loadUserConfig();
+      const configPaths = [
+        path.join(process.cwd(), ".maestro.json"),
+        path.join(process.cwd(), ".maestrorc.json"),
+        path.join(process.cwd(), "maestro.config.json"),
+        // グローバル設定ファイル
+        path.join(process.env.HOME || "~", ".maestrorc"),
+        path.join(process.env.HOME || "~", ".maestrorc.json")
+      ];
+      for (const configPath of configPaths) {
+        try {
+          const configData = await fs.readFile(configPath, "utf-8");
+          const parsedConfig = JSON.parse(configData);
+          this.projectConfig = ConfigSchema.parse(parsedConfig);
+          return;
+        } catch {
+        }
+      }
+    } catch (error) {
+      console.error("\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u8A2D\u5B9A\u306E\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F:", error);
+    }
+  }
+  async loadUserConfig() {
+    try {
+      const userConfigPath = path.join(process.cwd(), ".maestro.local.json");
+      const configData = await fs.readFile(userConfigPath, "utf-8");
+      const parsedConfig = JSON.parse(configData);
+      this.userConfig = ConfigSchema.parse(parsedConfig);
+    } catch {
+      this.userConfig = null;
+    }
+  }
+  // 設定を取得（ユーザー設定 > プロジェクト設定 > グローバル設定 > デフォルト）
+  get(key) {
+    if (this.userConfig && this.userConfig[key] !== void 0) {
+      return this.userConfig[key];
+    }
+    if (this.projectConfig && this.projectConfig[key] !== void 0) {
+      return this.projectConfig[key];
+    }
+    return this.conf.get(key) ?? DEFAULT_CONFIG[key];
+  }
+  // 設定を更新（グローバル設定のみ）
+  set(key, value) {
+    this.conf.set(key, value);
+  }
+  // 全設定を取得
+  getAll() {
+    const globalConfig = this.conf.store;
+    return {
+      ...DEFAULT_CONFIG,
+      ...globalConfig,
+      ...this.projectConfig || {},
+      ...this.userConfig || {}
+    };
+  }
+  // 設定ファイルのパスを取得
+  getConfigPath() {
+    return this.conf.path;
+  }
+  // ドット記法で設定値を取得
+  getConfigValue(keyPath) {
+    const keys = keyPath.split(".");
+    const config = this.getAll();
+    return keys.reduce((obj, key) => {
+      if (obj && typeof obj === "object" && key in obj) {
+        return obj[key];
+      }
+      return void 0;
+    }, config);
+  }
+  // ドット記法で設定値を設定
+  async setConfigValue(keyPath, value, target = "project") {
+    if (target === "user") {
+      await this.setUserConfigValue(keyPath, value);
+    } else {
+      await this.setProjectConfigValue(keyPath, value);
+    }
+  }
+  // ユーザー設定を設定
+  async setUserConfigValue(keyPath, value) {
+    const configPath = path.join(process.cwd(), ".maestro.local.json");
+    let userConfig = {};
+    try {
+      const configData = await fs.readFile(configPath, "utf-8");
+      userConfig = JSON.parse(configData);
+    } catch {
+    }
+    const keys = keyPath.split(".");
+    let current = userConfig;
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      if (!key) continue;
+      if (!current[key] || typeof current[key] !== "object") {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+    const lastKey = keys[keys.length - 1];
+    if (lastKey) {
+      current[lastKey] = this.parseValue(value);
+    }
+    const validatedConfig = ConfigSchema.parse(userConfig);
+    await fs.writeFile(configPath, JSON.stringify(validatedConfig, null, 2) + "\n", "utf-8");
+    this.userConfig = validatedConfig;
+  }
+  // プロジェクト設定を設定
+  async setProjectConfigValue(keyPath, value) {
+    const configPath = path.join(process.cwd(), ".maestro.json");
+    let projectConfig = {};
+    try {
+      const configData = await fs.readFile(configPath, "utf-8");
+      projectConfig = JSON.parse(configData);
+    } catch {
+    }
+    const keys = keyPath.split(".");
+    let current = projectConfig;
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      if (!key) continue;
+      if (!current[key] || typeof current[key] !== "object") {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+    const lastKey = keys[keys.length - 1];
+    if (lastKey) {
+      current[lastKey] = this.parseValue(value);
+    }
+    const validatedConfig = ConfigSchema.parse(projectConfig);
+    await fs.writeFile(configPath, JSON.stringify(validatedConfig, null, 2) + "\n", "utf-8");
+    this.projectConfig = validatedConfig;
+  }
+  // 設定値をリセット（デフォルトに戻す）
+  async resetConfigValue(keyPath) {
+    const configPath = path.join(process.cwd(), ".maestro.json");
+    let projectConfig = {};
+    try {
+      const configData = await fs.readFile(configPath, "utf-8");
+      projectConfig = JSON.parse(configData);
+    } catch {
+      return;
+    }
+    const keys = keyPath.split(".");
+    let current = projectConfig;
+    const parents = [];
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      if (!key || !current[key]) {
+        return;
+      }
+      parents.push({ obj: current, key });
+      current = current[key];
+    }
+    const lastKey = keys[keys.length - 1];
+    if (lastKey && current[lastKey] !== void 0) {
+      delete current[lastKey];
+    }
+    this.cleanEmptyObjects(projectConfig, keyPath.split(".").slice(0, -1));
+    await fs.writeFile(configPath, JSON.stringify(projectConfig, null, 2) + "\n", "utf-8");
+    this.projectConfig = Object.keys(projectConfig).length > 0 ? projectConfig : null;
+  }
+  // 値の型変換
+  parseValue(value) {
+    if (typeof value === "string") {
+      if (value === "true") return true;
+      if (value === "false") return false;
+      if (/^\d+$/.test(value)) return parseInt(value, 10);
+      if (/^\d+\.\d+$/.test(value)) return parseFloat(value);
+    }
+    return value;
+  }
+  // 空のオブジェクトを削除
+  cleanEmptyObjects(obj, keys) {
+    if (keys.length === 0) return;
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      if (!key || !current[key]) return;
+      current = current[key];
+    }
+    const lastKey = keys[keys.length - 1];
+    if (lastKey && current[lastKey] && typeof current[lastKey] === "object" && Object.keys(current[lastKey]).length === 0) {
+      delete current[lastKey];
+      this.cleanEmptyObjects(obj, keys.slice(0, -1));
+    }
+  }
+  // プロジェクト設定ファイルの作成
+  async createProjectConfig(configPath) {
+    const targetPath = configPath || path.join(process.cwd(), ".maestro.json");
+    const exampleConfig = {
+      worktrees: {
+        path: "../maestro-{branch}",
+        branchPrefix: "feature/",
+        directoryPrefix: "maestro-"
+      },
+      development: {
+        autoSetup: true,
+        syncFiles: [".env", ".env.local"],
+        defaultEditor: "cursor"
+      },
+      tmux: {
+        enabled: true,
+        openIn: "window",
+        sessionNaming: "{branch}"
+      },
+      claude: {
+        markdownMode: "shared"
+      },
+      github: {
+        autoFetch: true,
+        branchNaming: {
+          prTemplate: "pr-{number}",
+          issueTemplate: "issue-{number}"
+        }
+      },
+      ui: {
+        pathDisplay: "absolute"
+      },
+      hooks: {
+        afterCreate: "npm install",
+        beforeDelete: 'echo "\u30AA\u30FC\u30B1\u30B9\u30C8\u30E9\u30E1\u30F3\u30D0\u30FC\u3092\u89E3\u6563\u3057\u307E\u3059: $MAESTRO_BRANCH"'
+      },
+      postCreate: {
+        copyFiles: [".env", ".env.local"],
+        commands: ["pnpm install", "pnpm run dev"]
+      }
+    };
+    await fs.writeFile(targetPath, JSON.stringify(exampleConfig, null, 2) + "\n", "utf-8");
+  }
+};
+
+// src/core/git.ts
+import path2 from "path";
+import fs2 from "fs/promises";
+import chalk from "chalk";
+import inquirer from "inquirer";
+var GitWorktreeManager = class {
+  git;
+  configManager;
+  constructor(baseDir) {
+    this.git = simpleGit(baseDir || process.cwd());
+    this.configManager = new ConfigManager();
+  }
+  async createWorktree(branchName, baseBranch, skipDirCheck) {
+    await this.checkBranchNameCollision(branchName);
+    await this.configManager.loadProjectConfig();
+    const worktreeConfig = this.configManager.get("worktrees");
+    const directoryPrefix = worktreeConfig?.directoryPrefix || "";
+    const repoRoot = await this.getRepositoryRoot();
+    const worktreePath = path2.join(repoRoot, "..", `${directoryPrefix}${branchName}`);
+    if (!skipDirCheck) {
+      const dirExists = await this.checkDirectoryExists(worktreePath);
+      if (dirExists) {
+        const action = await this.handleExistingDirectory(worktreePath, branchName);
+        if (action === "cancel") {
+          throw new Error("\u30EF\u30FC\u30AF\u30C4\u30EA\u30FC\u306E\u4F5C\u6210\u304C\u30AD\u30E3\u30F3\u30BB\u30EB\u3055\u308C\u307E\u3057\u305F");
+        } else if (action === "rename") {
+          const branches = await this.getAllBranches();
+          const allBranches = [
+            ...branches.local,
+            ...branches.remote.map((r) => r.replace(/^[^/]+\//, ""))
+          ];
+          const alternativeName = this.generateAlternativeBranchName(branchName, allBranches);
+          console.log(chalk.yellow(`
+\u65B0\u3057\u3044\u30D6\u30E9\u30F3\u30C1\u540D: ${alternativeName}`));
+          return this.createWorktree(alternativeName, baseBranch, true);
+        } else if (action === "delete") {
+          await fs2.rm(worktreePath, { recursive: true, force: true });
+          console.log(
+            chalk.gray(`\u{1F5D1}\uFE0F  \u65E2\u5B58\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3092\u524A\u9664\u3057\u307E\u3057\u305F: ${path2.basename(worktreePath)}`)
+          );
+        }
+      }
+    }
+    if (!baseBranch) {
+      const status = await this.git.status();
+      baseBranch = status.current || "main";
+    }
+    await this.git.raw(["worktree", "add", "-b", branchName, worktreePath, baseBranch]);
+    return path2.resolve(worktreePath);
+  }
+  async attachWorktree(existingBranch, skipDirCheck) {
+    await this.configManager.loadProjectConfig();
+    const worktreeConfig = this.configManager.get("worktrees");
+    const directoryPrefix = worktreeConfig?.directoryPrefix || "";
+    const repoRoot = await this.getRepositoryRoot();
+    const safeBranchName = existingBranch.replace(/\//g, "-");
+    const worktreePath = path2.join(repoRoot, "..", `${directoryPrefix}${safeBranchName}`);
+    if (!skipDirCheck) {
+      const dirExists = await this.checkDirectoryExists(worktreePath);
+      if (dirExists) {
+        const action = await this.handleExistingDirectory(worktreePath, safeBranchName);
+        if (action === "cancel") {
+          throw new Error("\u30EF\u30FC\u30AF\u30C4\u30EA\u30FC\u306E\u4F5C\u6210\u304C\u30AD\u30E3\u30F3\u30BB\u30EB\u3055\u308C\u307E\u3057\u305F");
+        } else if (action === "rename") {
+          const branches = await this.getAllBranches();
+          const allBranches = [
+            ...branches.local,
+            ...branches.remote.map((r) => r.replace(/^[^/]+\//, ""))
+          ];
+          const alternativeName = this.generateAlternativeBranchName(safeBranchName, allBranches);
+          const newWorktreePath = path2.join(repoRoot, "..", `${directoryPrefix}${alternativeName}`);
+          console.log(chalk.yellow(`
+\u65B0\u3057\u3044\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u540D: ${alternativeName}`));
+          await this.git.raw(["worktree", "add", newWorktreePath, existingBranch]);
+          return path2.resolve(newWorktreePath);
+        } else if (action === "delete") {
+          await fs2.rm(worktreePath, { recursive: true, force: true });
+          console.log(
+            chalk.gray(`\u{1F5D1}\uFE0F  \u65E2\u5B58\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3092\u524A\u9664\u3057\u307E\u3057\u305F: ${path2.basename(worktreePath)}`)
+          );
+        }
+      }
+    }
+    await this.git.raw(["worktree", "add", worktreePath, existingBranch]);
+    return path2.resolve(worktreePath);
+  }
+  async listWorktrees() {
+    const output = await this.git.raw(["worktree", "list", "--porcelain"]);
+    const worktrees = [];
+    const lines = output.split("\n").filter((line) => line.trim());
+    let currentWorktree = {};
+    for (const line of lines) {
+      if (line.startsWith("worktree ")) {
+        if (currentWorktree.path) {
+          worktrees.push(currentWorktree);
+        }
+        currentWorktree = {
+          path: line.substring(9),
+          detached: false,
+          prunable: false,
+          locked: false
+        };
+      } else if (line.startsWith("HEAD ")) {
+        currentWorktree.head = line.substring(5);
+      } else if (line.startsWith("branch ")) {
+        currentWorktree.branch = line.substring(7);
+      } else if (line === "detached") {
+        currentWorktree.detached = true;
+      } else if (line === "prunable") {
+        currentWorktree.prunable = true;
+      } else if (line.startsWith("locked")) {
+        currentWorktree.locked = true;
+        if (line.includes(" ")) {
+          currentWorktree.reason = line.substring(line.indexOf(" ") + 1);
+        }
+      }
+    }
+    if (currentWorktree.path) {
+      worktrees.push(currentWorktree);
+    }
+    return worktrees;
+  }
+  async deleteWorktree(branchName, force = false) {
+    const worktrees = await this.listWorktrees();
+    const worktree = worktrees.find((wt) => {
+      const branch = wt.branch?.replace("refs/heads/", "");
+      return branch === branchName;
+    });
+    if (!worktree) {
+      throw new Error(`\u30EF\u30FC\u30AF\u30C4\u30EA\u30FC '${branchName}' \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093`);
+    }
+    const args = ["worktree", "remove"];
+    if (force) args.push("--force");
+    args.push(worktree.path);
+    await this.git.raw(args);
+    await this.cleanupEmptyDirectories(worktree.path);
+    try {
+      await this.git.branch(["-d", branchName]);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("not fully merged")) {
+        await this.git.branch(["-D", branchName]);
+      } else {
+        throw error;
+      }
+    }
+  }
+  async getCurrentBranch() {
+    const status = await this.git.status();
+    return status.current;
+  }
+  async isGitRepository() {
+    try {
+      await this.git.status();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getAllBranches() {
+    const localBranches = await this.git.branchLocal();
+    const remoteBranches = await this.git.branch(["-r"]);
+    return {
+      local: localBranches.all.filter((b) => !b.startsWith("remotes/")),
+      remote: remoteBranches.all.filter((b) => b.startsWith("remotes/")).map((b) => b.replace("remotes/", ""))
+    };
+  }
+  async listLocalBranches() {
+    const localBranches = await this.git.branchLocal();
+    return localBranches.all.filter((b) => !b.startsWith("remotes/"));
+  }
+  async fetchAll() {
+    await this.git.fetch(["--all"]);
+  }
+  async getLastCommit(worktreePath) {
+    try {
+      const gitInWorktree = simpleGit(worktreePath);
+      const log = await gitInWorktree.log({ maxCount: 1 });
+      if (log.latest) {
+        return {
+          date: log.latest.date,
+          message: log.latest.message,
+          hash: log.latest.hash.substring(0, 7)
+        };
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  async getRepositoryRoot() {
+    try {
+      const output = await this.git.raw(["rev-parse", "--show-toplevel"]);
+      return output.trim();
+    } catch {
+      throw new Error("\u30EA\u30DD\u30B8\u30C8\u30EA\u30EB\u30FC\u30C8\u306E\u53D6\u5F97\u306B\u5931\u6557\u3057\u307E\u3057\u305F");
+    }
+  }
+  async isGitignored(filePath) {
+    try {
+      await this.git.raw(["check-ignore", filePath]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async checkBranchNameCollision(branchName) {
+    const branches = await this.getAllBranches();
+    const allBranches = [...branches.local, ...branches.remote.map((r) => r.replace(/^[^/]+\//, ""))];
+    if (allBranches.includes(branchName)) {
+      throw new Error(`\u30D6\u30E9\u30F3\u30C1 '${branchName}' \u306F\u65E2\u306B\u5B58\u5728\u3057\u307E\u3059`);
+    }
+    const conflictingBranches = allBranches.filter(
+      (existing) => existing.startsWith(branchName + "/")
+    );
+    if (conflictingBranches.length > 0) {
+      const examples = conflictingBranches.slice(0, 3).join(", ");
+      throw new Error(
+        `\u30D6\u30E9\u30F3\u30C1 '${branchName}' \u3092\u4F5C\u6210\u3067\u304D\u307E\u305B\u3093\u3002\u4EE5\u4E0B\u306E\u65E2\u5B58\u30D6\u30E9\u30F3\u30C1\u3068\u7AF6\u5408\u3057\u307E\u3059: ${examples}${conflictingBranches.length > 3 ? ` \u306A\u3069 (${conflictingBranches.length}\u4EF6)` : ""}`
+      );
+    }
+    const parentConflicts = allBranches.filter((existing) => branchName.startsWith(existing + "/"));
+    if (parentConflicts.length > 0) {
+      const examples = parentConflicts.slice(0, 3).join(", ");
+      throw new Error(
+        `\u30D6\u30E9\u30F3\u30C1 '${branchName}' \u3092\u4F5C\u6210\u3067\u304D\u307E\u305B\u3093\u3002\u4EE5\u4E0B\u306E\u65E2\u5B58\u30D6\u30E9\u30F3\u30C1\u306E\u30B5\u30D6\u30D6\u30E9\u30F3\u30C1\u306B\u306A\u308A\u307E\u3059: ${examples}${parentConflicts.length > 3 ? ` \u306A\u3069 (${parentConflicts.length}\u4EF6)` : ""}`
+      );
+    }
+  }
+  generateAlternativeBranchName(originalName, allBranches) {
+    let counter = 1;
+    let alternativeName = `${originalName}-${counter}`;
+    while (allBranches.includes(alternativeName) || allBranches.some(
+      (b) => b.startsWith(alternativeName + "/") || alternativeName.startsWith(b + "/")
+    )) {
+      counter++;
+      alternativeName = `${originalName}-${counter}`;
+    }
+    return alternativeName;
+  }
+  async cleanupEmptyDirectories(worktreePath) {
+    const repoRoot = await this.getRepositoryRoot();
+    const baseDir = path2.join(repoRoot, "..");
+    let currentDir = path2.dirname(worktreePath);
+    while (currentDir !== baseDir && currentDir !== path2.dirname(currentDir)) {
+      try {
+        const entries = await fs2.readdir(currentDir);
+        if (entries.length === 0) {
+          await fs2.rmdir(currentDir);
+          console.log(chalk.gray(`\u{1F9F9} Removed empty directory: ${path2.basename(currentDir)}`));
+          currentDir = path2.dirname(currentDir);
+        } else {
+          break;
+        }
+      } catch {
+        break;
+      }
+    }
+  }
+  async checkDirectoryExists(dirPath) {
+    try {
+      const stats = await fs2.stat(dirPath);
+      return stats.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  async handleExistingDirectory(dirPath, branchName) {
+    const repoRoot = await this.getRepositoryRoot();
+    const relativePath = path2.relative(repoRoot, dirPath);
+    console.log(chalk.yellow(`
+\u26A0\uFE0F  \u30C7\u30A3\u30EC\u30AF\u30C8\u30EA '${relativePath}' \u306F\u65E2\u306B\u5B58\u5728\u3057\u307E\u3059`));
+    const choices = [
+      { name: "\u65E2\u5B58\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3092\u524A\u9664\u3057\u3066\u65B0\u898F\u4F5C\u6210", value: "delete" },
+      { name: `\u5225\u306E\u540D\u524D\u3092\u4F7F\u7528\uFF08${branchName}-2\u306A\u3069\uFF09`, value: "rename" },
+      { name: "\u30AD\u30E3\u30F3\u30BB\u30EB", value: "cancel" }
+    ];
+    const answer = await inquirer.prompt([
+      {
+        type: "list",
+        name: "action",
+        message: "\u3069\u306E\u3088\u3046\u306B\u51E6\u7406\u3057\u307E\u3059\u304B\uFF1F",
+        choices
+      }
+    ]);
+    return answer.action;
+  }
+};
+
+// src/mcp/server.ts
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+var isTestEnvironment = process.env.NODE_ENV === "test";
+var __dirname2 = dirname(fileURLToPath(import.meta.url));
+var packageJson = JSON.parse(readFileSync(join(__dirname2, "../../package.json"), "utf-8"));
+var CreateWorktreeArgsSchema = z2.object({
+  branchName: z2.string().describe("\u4F5C\u6210\u3059\u308B\u30D6\u30E9\u30F3\u30C1\u540D"),
+  baseBranch: z2.string().optional().describe("\u30D9\u30FC\u30B9\u30D6\u30E9\u30F3\u30C1\uFF08\u7701\u7565\u6642\u306F\u73FE\u5728\u306E\u30D6\u30E9\u30F3\u30C1\uFF09")
+});
+var DeleteWorktreeArgsSchema = z2.object({
+  branchName: z2.string().describe("\u524A\u9664\u3059\u308B\u30D6\u30E9\u30F3\u30C1\u540D"),
+  force: z2.boolean().optional().describe("\u5F37\u5236\u524A\u9664\u30D5\u30E9\u30B0")
+});
+var ExecInWorktreeArgsSchema = z2.object({
+  branchName: z2.string().describe("\u5B9F\u884C\u5BFE\u8C61\u306E\u30D6\u30E9\u30F3\u30C1\u540D"),
+  command: z2.string().describe("\u5B9F\u884C\u3059\u308B\u30B3\u30DE\u30F3\u30C9")
+});
+var server = new Server(
+  {
+    name: "maestro",
+    version: packageJson.version
+  },
+  {
+    capabilities: {
+      tools: {}
+    }
+  }
+);
+var gitManager = new GitWorktreeManager();
+var TOOLS = [
+  {
+    name: "create_orchestra_member",
+    description: "\u65B0\u3057\u3044\u6F14\u594F\u8005\uFF08Git worktree\uFF09\u3092\u62DB\u96C6\u3059\u308B",
+    inputSchema: {
+      type: "object",
+      properties: {
+        branchName: {
+          type: "string",
+          description: "\u4F5C\u6210\u3059\u308B\u30D6\u30E9\u30F3\u30C1\u540D"
+        },
+        baseBranch: {
+          type: "string",
+          description: "\u30D9\u30FC\u30B9\u30D6\u30E9\u30F3\u30C1\uFF08\u7701\u7565\u6642\u306F\u73FE\u5728\u306E\u30D6\u30E9\u30F3\u30C1\uFF09"
+        }
+      },
+      required: ["branchName"]
+    }
+  },
+  {
+    name: "list_orchestra_members",
+    description: "\u3059\u3079\u3066\u306E\u6F14\u594F\u8005\uFF08Git worktree\uFF09\u3092\u4E00\u89A7\u8868\u793A",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "delete_orchestra_member",
+    description: "\u6F14\u594F\u8005\uFF08Git worktree\uFF09\u3092\u89E3\u6563",
+    inputSchema: {
+      type: "object",
+      properties: {
+        branchName: {
+          type: "string",
+          description: "\u524A\u9664\u3059\u308B\u30D6\u30E9\u30F3\u30C1\u540D"
+        },
+        force: {
+          type: "boolean",
+          description: "\u5F37\u5236\u524A\u9664\u30D5\u30E9\u30B0"
+        }
+      },
+      required: ["branchName"]
+    }
+  },
+  {
+    name: "exec_in_orchestra_member",
+    description: "\u6F14\u594F\u8005\u3067\u30B3\u30DE\u30F3\u30C9\u3092\u5B9F\u884C",
+    inputSchema: {
+      type: "object",
+      properties: {
+        branchName: {
+          type: "string",
+          description: "\u5B9F\u884C\u5BFE\u8C61\u306E\u30D6\u30E9\u30F3\u30C1\u540D"
+        },
+        command: {
+          type: "string",
+          description: "\u5B9F\u884C\u3059\u308B\u30B3\u30DE\u30F3\u30C9"
+        }
+      },
+      required: ["branchName", "command"]
+    }
+  }
+];
+if (!isTestEnvironment) {
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: TOOLS
+    };
+  });
+}
+if (!isTestEnvironment) {
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      switch (name) {
+        case "create_orchestra_member": {
+          const validatedArgs = CreateWorktreeArgsSchema.parse(args);
+          const worktreePath = await gitManager.createWorktree(
+            validatedArgs.branchName,
+            validatedArgs.baseBranch
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `\u2705 \u6F14\u594F\u8005 '${validatedArgs.branchName}' \u3092\u62DB\u96C6\u3057\u307E\u3057\u305F\uFF01
+\u{1F4C1} ${worktreePath}`
+              }
+            ]
+          };
+        }
+        case "list_orchestra_members": {
+          const worktrees = await gitManager.listWorktrees();
+          const orchestraMembers = worktrees.filter((wt) => !wt.path.endsWith("."));
+          const list = orchestraMembers.map((wt) => {
+            const branchName = wt.branch?.replace("refs/heads/", "") || wt.branch;
+            return `\u2022 ${branchName} (${wt.path})`;
+          }).join("\n");
+          return {
+            content: [
+              {
+                type: "text",
+                text: orchestraMembers.length > 0 ? `\u{1F3BC} \u30AA\u30FC\u30B1\u30B9\u30C8\u30E9\u7DE8\u6210(worktree):
+${list}
+
+\u5408\u8A08: ${orchestraMembers.length} \u540D\u306E\u6F14\u594F\u8005` : "\u6F14\u594F\u8005\u304C\u5B58\u5728\u3057\u307E\u305B\u3093"
+              }
+            ]
+          };
+        }
+        case "delete_orchestra_member": {
+          const validatedArgs = DeleteWorktreeArgsSchema.parse(args);
+          await gitManager.deleteWorktree(validatedArgs.branchName, validatedArgs.force);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `\u2705 \u6F14\u594F\u8005 '${validatedArgs.branchName}' \u3092\u89E3\u6563\u3057\u307E\u3057\u305F`
+              }
+            ]
+          };
+        }
+        case "exec_in_orchestra_member": {
+          const validatedArgs = ExecInWorktreeArgsSchema.parse(args);
+          const { execa } = await import("execa");
+          const worktrees = await gitManager.listWorktrees();
+          const targetWorktree = worktrees.find((wt) => {
+            const branch = wt.branch?.replace("refs/heads/", "");
+            return branch === validatedArgs.branchName || wt.branch === validatedArgs.branchName;
+          });
+          if (!targetWorktree) {
+            throw new Error(`\u6F14\u594F\u8005 '${validatedArgs.branchName}' \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093`);
+          }
+          const result = await execa("sh", ["-c", validatedArgs.command], {
+            cwd: targetWorktree.path
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: `\u{1F4CD} ${validatedArgs.branchName} \u3067\u5B9F\u884C: ${validatedArgs.command}
+
+${result.stdout}`
+              }
+            ]
+          };
+        }
+        default:
+          throw new Error(`\u4E0D\u660E\u306A\u30C4\u30FC\u30EB: ${name}`);
+      }
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\u274C \u30A8\u30E9\u30FC: ${error instanceof Error ? error.message : "\u4E0D\u660E\u306A\u30A8\u30E9\u30FC"}`
+          }
+        ]
+      };
+    }
+  });
+}
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("\u{1F3BC} Maestro MCP server started");
+}
+if (!isTestEnvironment) {
+  main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+  });
+}
+export {
+  server
+};
+//# sourceMappingURL=server.js.map