@zelklab/seevo-mcp-server 0.1.0

package/README.md

@@ -0,0 +1,154 @@
+# Seevo MCP Server
+
+Claude CodeからSeevoバックエンドに直接プロジェクトを登録するためのMCPサーバーです。
+
+## 機能
+
+- **プロジェクト自動登録**: プロジェクトディレクトリを解析してSeevoに自動登録
+- **セキュアな認証**: ログイントークンを安全に保存・管理
+- **自動解析**: README.md、package.json等からサービス情報を自動抽出
+
+## セットアップ
+
+### 1. 依存関係のインストール
+
+```bash
+cd /Users/sugimoto/Desktop/seevo/mcp-server
+npm install
+```
+
+### 2. ビルド
+
+```bash
+npm run build
+```
+
+### 3. Claude Code設定
+
+`~/.config/claude-code/config.json` に以下を追加：
+
+```json
+{
+  "mcpServers": {
+    "seevo": {
+      "command": "node",
+      "args": ["/Users/sugimoto/Desktop/seevo/mcp-server/dist/index.js"]
+    }
+  }
+}
+```
+
+### 4. Claude Codeを再起動
+
+設定を反映するためにClaude Codeを再起動してください。
+
+## 使い方
+
+### 1. ログイン
+
+まずSeevoにログインします：
+
+```
+User: Seevoにログインして
+Claude Code: [seevo_login ツールを使用]
+```
+
+または直接：
+
+```
+User: メール test@example.com、パスワード password123 でSeevoにログインして
+```
+
+### 2. プロジェクト登録
+
+現在のプロジェクトをSeevoに登録：
+
+```
+User: このプロジェクトをSeevoに登録して
+Claude Code: [プロジェクトを解析してseevo_register_project ツールを使用]
+```
+
+特定のディレクトリを指定：
+
+```
+User: /Users/sugimoto/Desktop/myproject をSeevoに登録して
+```
+
+### 3. ログアウト
+
+```
+User: Seevoからログアウトして
+```
+
+## 利用可能なツール
+
+### `seevo_login`
+- Seevoにログインして認証トークンを保存
+- パラメータ: `email`, `password`
+
+### `seevo_register_project`
+- プロジェクトをSeevoに登録
+- パラメータ:
+  - `project_path` (省略可): プロジェクトディレクトリのパス
+  - `name` (省略可): サービス名
+
+### `seevo_logout`
+- ログアウトして認証トークンを削除
+
+## プロジェクト解析
+
+MCPサーバーは以下のファイルから自動的に情報を抽出します：
+
+- **プロジェクト名**: `package.json`, `go.mod`, `Cargo.toml`, またはディレクトリ名
+- **説明**: `README.md` の最初の段落、または `package.json` の description
+- **ターゲットユーザー**: 技術スタックとキーワードから推測
+
+## セキュリティ
+
+- 認証トークンは `~/.seevo/auth.json` に保存（権限600）
+- トークンは7日間有効
+- MCPサーバー経由のみでAPIにアクセス可能
+
+## トラブルシューティング
+
+### MCPサーバーが起動しない
+
+```bash
+# ビルドエラーがないか確認
+cd /Users/sugimoto/Desktop/seevo/mcp-server
+npm run build
+
+# 直接実行してエラーを確認
+node dist/index.js
+```
+
+### 認証エラー
+
+```bash
+# 認証情報をクリア
+rm ~/.seevo/auth.json
+
+# 再度ログイン
+```
+
+### Goバックエンドに接続できない
+
+- Goバックエンドが起動しているか確認: `http://localhost:8080`
+- 環境変数 `SEEVO_API_URL` で別のURLを指定可能
+
+## 開発
+
+```bash
+# 開発モード（TypeScriptをビルドして実行）
+npm run dev
+
+# TypeScriptをビルド
+npm run build
+
+# 実行
+npm start
+```
+
+## ライセンス
+
+MIT

package/dist/analyzer.js

@@ -0,0 +1,269 @@
+import { readFileSync, existsSync } from "fs";
+import { join, basename } from "path";
+/**
+ * プロジェクトディレクトリを解析してサービス情報を抽出
+ */
+export async function analyzeProject(projectPath, forcedName) {
+    // プロジェクト名を決定
+    const service_name = forcedName || detectProjectName(projectPath);
+    // README.mdから説明を抽出
+    const description = extractDescriptionFromReadme(projectPath) ||
+        extractDescriptionFromPackageJson(projectPath) ||
+        `${service_name}のマーケティングコンテンツ`;
+    // ターゲットオーディエンスを推測
+    const target = detectTargetAudience(projectPath);
+    // 技術スタックを検出
+    const tech_stack = detectTechStack(projectPath);
+    // 機能を検出（README.mdから抽出）
+    const features = detectFeatures(projectPath);
+    return {
+        service_name,
+        description,
+        target,
+        tech_stack: tech_stack.length > 0 ? tech_stack : undefined,
+        features: features.length > 0 ? features : undefined,
+    };
+}
+/**
+ * プロジェクト名を検出
+ */
+function detectProjectName(projectPath) {
+    // package.json から取得
+    const packageJsonPath = join(projectPath, "package.json");
+    if (existsSync(packageJsonPath)) {
+        try {
+            const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+            if (packageJson.name) {
+                return packageJson.name;
+            }
+        }
+        catch (error) {
+            // Ignore
+        }
+    }
+    // go.mod から取得
+    const goModPath = join(projectPath, "go.mod");
+    if (existsSync(goModPath)) {
+        try {
+            const goMod = readFileSync(goModPath, "utf-8");
+            const match = goMod.match(/module\s+([^\s]+)/);
+            if (match && match[1]) {
+                const parts = match[1].split("/");
+                return parts[parts.length - 1];
+            }
+        }
+        catch (error) {
+            // Ignore
+        }
+    }
+    // Cargo.toml から取得
+    const cargoTomlPath = join(projectPath, "Cargo.toml");
+    if (existsSync(cargoTomlPath)) {
+        try {
+            const cargoToml = readFileSync(cargoTomlPath, "utf-8");
+            const match = cargoToml.match(/name\s*=\s*"([^"]+)"/);
+            if (match && match[1]) {
+                return match[1];
+            }
+        }
+        catch (error) {
+            // Ignore
+        }
+    }
+    // ディレクトリ名をフォールバック
+    return basename(projectPath);
+}
+/**
+ * README.mdから説明を抽出
+ */
+function extractDescriptionFromReadme(projectPath) {
+    const readmePaths = [
+        join(projectPath, "README.md"),
+        join(projectPath, "readme.md"),
+        join(projectPath, "README"),
+    ];
+    for (const readmePath of readmePaths) {
+        if (existsSync(readmePath)) {
+            try {
+                const content = readFileSync(readmePath, "utf-8");
+                // タイトルの次の段落を抽出
+                const lines = content.split("\n");
+                let foundTitle = false;
+                let description = "";
+                for (const line of lines) {
+                    if (line.startsWith("#")) {
+                        foundTitle = true;
+                        continue;
+                    }
+                    if (foundTitle && line.trim() !== "") {
+                        description += line.trim() + " ";
+                        if (description.length > 200) {
+                            break;
+                        }
+                    }
+                }
+                if (description) {
+                    return description.trim().substring(0, 500);
+                }
+            }
+            catch (error) {
+                // Ignore
+            }
+        }
+    }
+    return null;
+}
+/**
+ * package.jsonから説明を抽出
+ */
+function extractDescriptionFromPackageJson(projectPath) {
+    const packageJsonPath = join(projectPath, "package.json");
+    if (existsSync(packageJsonPath)) {
+        try {
+            const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+            return packageJson.description || null;
+        }
+        catch (error) {
+            // Ignore
+        }
+    }
+    return null;
+}
+/**
+ * ターゲットオーディエンスを推測
+ */
+function detectTargetAudience(projectPath) {
+    const techStack = detectTechStack(projectPath);
+    const keywords = detectKeywords(projectPath);
+    // 技術スタックベースの推測
+    if (techStack.includes("react") || techStack.includes("vue") || techStack.includes("next.js")) {
+        return "Web開発者、スタートアップ";
+    }
+    if (techStack.includes("go") && keywords.includes("api")) {
+        return "バックエンド開発者、API利用者";
+    }
+    if (techStack.includes("python") && (keywords.includes("ml") || keywords.includes("ai"))) {
+        return "データサイエンティスト、AI/ML エンジニア";
+    }
+    if (keywords.includes("cli") || keywords.includes("tool")) {
+        return "開発者、エンジニア";
+    }
+    // デフォルト
+    return "スタートアップの開発者、中小企業";
+}
+/**
+ * 技術スタックを検出
+ */
+function detectTechStack(projectPath) {
+    const stack = [];
+    // package.json
+    if (existsSync(join(projectPath, "package.json"))) {
+        try {
+            const packageJson = JSON.parse(readFileSync(join(projectPath, "package.json"), "utf-8"));
+            const deps = {
+                ...packageJson.dependencies,
+                ...packageJson.devDependencies,
+            };
+            if (deps.next)
+                stack.push("Next.js");
+            else if (deps.react)
+                stack.push("React");
+            if (deps.vue)
+                stack.push("Vue");
+            if (deps.express)
+                stack.push("Express");
+            if (deps.typescript || deps["@types/node"])
+                stack.push("TypeScript");
+            if (deps.tailwindcss || deps["tailwindcss"])
+                stack.push("Tailwind CSS");
+            if (deps.postgresql || deps.pg)
+                stack.push("PostgreSQL");
+        }
+        catch (error) {
+            // Ignore
+        }
+    }
+    // go.mod
+    if (existsSync(join(projectPath, "go.mod"))) {
+        stack.push("Go");
+    }
+    // requirements.txt or setup.py
+    if (existsSync(join(projectPath, "requirements.txt")) ||
+        existsSync(join(projectPath, "setup.py"))) {
+        stack.push("Python");
+    }
+    // Cargo.toml
+    if (existsSync(join(projectPath, "Cargo.toml"))) {
+        stack.push("Rust");
+    }
+    // Docker
+    if (existsSync(join(projectPath, "Dockerfile")) || existsSync(join(projectPath, "docker-compose.yml"))) {
+        stack.push("Docker");
+    }
+    return stack;
+}
+/**
+ * キーワードを検出
+ */
+function detectKeywords(projectPath) {
+    const keywords = [];
+    // README.mdからキーワード抽出
+    const readmePath = join(projectPath, "README.md");
+    if (existsSync(readmePath)) {
+        try {
+            const content = readFileSync(readmePath, "utf-8").toLowerCase();
+            if (content.includes("api"))
+                keywords.push("api");
+            if (content.includes("cli"))
+                keywords.push("cli");
+            if (content.includes("tool"))
+                keywords.push("tool");
+            if (content.includes("machine learning") || content.includes("ml"))
+                keywords.push("ml");
+            if (content.includes("artificial intelligence") || content.includes("ai"))
+                keywords.push("ai");
+            if (content.includes("web app") || content.includes("webapp"))
+                keywords.push("webapp");
+        }
+        catch (error) {
+            // Ignore
+        }
+    }
+    return keywords;
+}
+/**
+ * 機能を検出（README.mdから）
+ */
+function detectFeatures(projectPath) {
+    const features = [];
+    const readmePath = join(projectPath, "README.md");
+    if (existsSync(readmePath)) {
+        try {
+            const content = readFileSync(readmePath, "utf-8");
+            const lines = content.split("\n");
+            let inFeaturesSection = false;
+            for (const line of lines) {
+                // 機能セクションの開始を検出
+                if (line.match(/^##?\s+(Features|機能|主な機能|Main Features)/i)) {
+                    inFeaturesSection = true;
+                    continue;
+                }
+                // 次のセクション見出しで終了
+                if (inFeaturesSection && line.match(/^##?\s+/)) {
+                    break;
+                }
+                // リスト項目を抽出
+                if (inFeaturesSection) {
+                    const listMatch = line.match(/^[\s]*[-*+]\s+(.+)/);
+                    if (listMatch && listMatch[1]) {
+                        features.push(listMatch[1].trim());
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Ignore
+        }
+    }
+    return features.slice(0, 10); // 最大10個まで
+}

package/dist/auth.js

@@ -0,0 +1,97 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+/**
+ * 認証トークン管理クラス
+ * ユーザーのホームディレクトリにMCPトークンを安全に保存
+ */
+export class AuthManager {
+    configDir;
+    authFile;
+    authData = null;
+    constructor() {
+        this.configDir = join(homedir(), ".seevo");
+        this.authFile = join(this.configDir, "auth.json");
+        this.loadToken();
+    }
+    /**
+     * 認証トークンを読み込む
+     * 優先順位: 1. 環境変数 SEEVO_MCP_TOKEN, 2. ファイル ~/.seevo/auth.json
+     */
+    loadToken() {
+        try {
+            // 1. 環境変数から読み込み（Claude Code設定で渡される）
+            const envToken = process.env.SEEVO_MCP_TOKEN;
+            if (envToken) {
+                // 環境変数のトークンは30日間有効とみなす
+                this.authData = {
+                    token: envToken,
+                    expiresAt: Date.now() + 30 * 24 * 60 * 60 * 1000,
+                };
+                console.error("Auth: Using token from environment variable");
+                return;
+            }
+            // 2. ファイルから読み込み
+            if (existsSync(this.authFile)) {
+                const data = readFileSync(this.authFile, "utf-8");
+                this.authData = JSON.parse(data);
+                // トークンが期限切れかチェック
+                if (this.authData && this.authData.expiresAt < Date.now()) {
+                    this.authData = null;
+                }
+                else if (this.authData) {
+                    console.error("Auth: Using token from file");
+                }
+            }
+        }
+        catch (error) {
+            console.error("Failed to load auth token:", error);
+            this.authData = null;
+        }
+    }
+    /**
+     * MCPトークンを保存 (30日間有効)
+     */
+    saveToken(token, expiresInDays = 30) {
+        try {
+            // ディレクトリが存在しない場合は作成
+            if (!existsSync(this.configDir)) {
+                mkdirSync(this.configDir, { recursive: true });
+            }
+            const expiresAt = Date.now() + expiresInDays * 24 * 60 * 60 * 1000;
+            this.authData = { token, expiresAt };
+            writeFileSync(this.authFile, JSON.stringify(this.authData, null, 2), {
+                mode: 0o600, // 所有者のみ読み書き可能
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to save auth token: ${error}`);
+        }
+    }
+    /**
+     * MCPトークンを取得
+     */
+    getToken() {
+        return this.authData?.token || null;
+    }
+    /**
+     * 認証済みかチェック
+     */
+    isAuthenticated() {
+        return this.authData !== null && this.authData.expiresAt > Date.now();
+    }
+    /**
+     * 認証トークンをクリア
+     */
+    clearToken() {
+        this.authData = null;
+        try {
+            if (existsSync(this.authFile)) {
+                writeFileSync(this.authFile, "");
+            }
+        }
+        catch (error) {
+            console.error("Failed to clear auth token:", error);
+        }
+    }
+}

package/dist/client.js

@@ -0,0 +1,98 @@
+import fetch from "node-fetch";
+/**
+ * Seevoバックエンドとの通信クライアント
+ */
+export class SeeveClient {
+    baseUrl;
+    authManager;
+    constructor(authManager) {
+        this.baseUrl = process.env.SEEVO_API_URL || "http://localhost:8080/api/v1";
+        this.authManager = authManager;
+    }
+    /**
+     * ログイン
+     */
+    async login(email, password) {
+        // Step 1: Login to get JWT token in cookie
+        const loginResponse = await fetch(`${this.baseUrl}/auth/login`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ email, password }),
+        });
+        if (!loginResponse.ok) {
+            const error = await loginResponse.text();
+            throw new Error(`Login failed: ${error}`);
+        }
+        // Extract JWT token from cookie header
+        const setCookie = loginResponse.headers.get("set-cookie");
+        if (!setCookie) {
+            throw new Error("No authentication cookie received");
+        }
+        const tokenMatch = setCookie.match(/token=([^;]+)/);
+        if (!tokenMatch) {
+            throw new Error("Failed to extract authentication token");
+        }
+        const jwtToken = tokenMatch[1];
+        // Step 2: Request MCP token using the JWT token
+        const mcpTokenResponse = await fetch(`${this.baseUrl}/auth/mcp-token`, {
+            method: "POST",
+            headers: {
+                Cookie: `token=${jwtToken}`,
+            },
+        });
+        if (!mcpTokenResponse.ok) {
+            const error = await mcpTokenResponse.text();
+            throw new Error(`Failed to generate MCP token: ${error}`);
+        }
+        const mcpTokenData = (await mcpTokenResponse.json());
+        // Save the MCP token (not the JWT token)
+        this.authManager.saveToken(mcpTokenData.token);
+        const loginData = await loginResponse.json();
+        return loginData;
+    }
+    /**
+     * プロジェクトを登録
+     */
+    async registerProject(projectData) {
+        const token = this.authManager.getToken();
+        if (!token) {
+            throw new Error("Not authenticated. Please login first.");
+        }
+        const response = await fetch(`${this.baseUrl}/apps`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify(projectData),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Failed to register project: ${error}`);
+        }
+        const data = await response.json();
+        return data;
+    }
+    /**
+     * 現在のユーザー情報を取得
+     */
+    async getCurrentUser() {
+        const token = this.authManager.getToken();
+        if (!token) {
+            throw new Error("Not authenticated. Please login first.");
+        }
+        const response = await fetch(`${this.baseUrl}/auth/me`, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error("Failed to get current user");
+        }
+        const data = (await response.json());
+        return data.user;
+    }
+}

package/dist/index.js

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+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 { analyzeProject } from "./analyzer.js";
+import { SeeveClient } from "./client.js";
+import { AuthManager } from "./auth.js";
+// MCP Server for Seevo
+const server = new Server({
+    name: "seevo-mcp-server",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Initialize auth manager
+const authManager = new AuthManager();
+const seeveClient = new SeeveClient(authManager);
+// Define available tools
+const TOOLS = [
+    {
+        name: "seevo_register_project",
+        description: "現在のプロジェクトをSeevoに登録します。プロジェクトディレクトリを解析してサービス情報を自動抽出し、Seevoバックエンドに登録します。",
+        inputSchema: {
+            type: "object",
+            properties: {
+                project_path: {
+                    type: "string",
+                    description: "プロジェクトディレクトリのパス（省略時はカレントディレクトリ）",
+                },
+                name: {
+                    type: "string",
+                    description: "サービス名（省略時は自動検出）",
+                },
+            },
+        },
+    },
+    {
+        name: "seevo_login",
+        description: "Seevoにログインして認証トークンを保存します。一度ログインすれば、以降の操作で自動的に認証されます。",
+        inputSchema: {
+            type: "object",
+            properties: {
+                email: {
+                    type: "string",
+                    description: "メールアドレス",
+                },
+                password: {
+                    type: "string",
+                    description: "パスワード",
+                },
+            },
+            required: ["email", "password"],
+        },
+    },
+    {
+        name: "seevo_logout",
+        description: "Seevoからログアウトして保存された認証トークンを削除します。",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+];
+// Handle list_tools request
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: TOOLS };
+});
+// Handle call_tool request
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case "seevo_register_project": {
+                const projectPath = args?.project_path || process.cwd();
+                const projectName = args?.name;
+                // Check authentication
+                if (!authManager.isAuthenticated()) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "エラー: Seevoにログインしていません。先に seevo_login ツールでログインしてください。",
+                            },
+                        ],
+                    };
+                }
+                // Analyze project
+                const analysis = await analyzeProject(projectPath, projectName);
+                // Register to Seevo
+                const result = await seeveClient.registerProject(analysis);
+                const techStackText = result.tech_stack && result.tech_stack.length > 0
+                    ? `\n**技術スタック**: ${result.tech_stack.join(", ")}`
+                    : "";
+                const featuresText = result.features && result.features.length > 0
+                    ? `\n**主な機能**:\n${result.features.map(f => `  - ${f}`).join("\n")}`
+                    : "";
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `✅ プロジェクトをSeevoに登録しました！
+
+**サービス名**: ${result.service_name}
+**説明**: ${result.description}
+**ターゲット**: ${result.target}${techStackText}${featuresText}
+**アプリID**: ${result.id}
+
+Seevoダッシュボードで確認できます: http://localhost:3000/dashboard?project=${result.id}`,
+                        },
+                    ],
+                };
+            }
+            case "seevo_login": {
+                const email = args?.email;
+                const password = args?.password;
+                if (!email || !password) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "エラー: emailとpasswordは必須です。",
+                            },
+                        ],
+                    };
+                }
+                const loginResult = await seeveClient.login(email, password);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `✅ Seevoにログインしました！
+
+**ユーザー名**: ${loginResult.user.name}
+**メール**: ${loginResult.user.email}
+
+これで seevo_register_project ツールを使用できます。`,
+                        },
+                    ],
+                };
+            }
+            case "seevo_logout": {
+                authManager.clearToken();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "✅ Seevoからログアウトしました。",
+                        },
+                    ],
+                };
+            }
+            default:
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `エラー: 不明なツール '${name}'`,
+                        },
+                    ],
+                    isError: true,
+                };
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `エラー: ${errorMessage}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Start server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Seevo MCP Server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/dist/setup.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { homedir, platform } from "os";
+import { join } from "path";
+const SEEVO_API_URL = process.env.SEEVO_API_URL || "http://localhost:8080/api/v1";
+// OS別のグローバル設定パスを取得
+function getGlobalConfigPath() {
+    const os = platform();
+    switch (os) {
+        case "darwin": // macOS
+            return join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+        case "win32": // Windows
+            return join(process.env.APPDATA || "", "Claude", "claude_desktop_config.json");
+        case "linux":
+            return join(homedir(), ".config", "Claude", "claude_desktop_config.json");
+        default:
+            throw new Error(`Unsupported OS: ${os}`);
+    }
+}
+function setupMCP(token, isGlobal, projectPath) {
+    console.log("\n🚀 Seevo MCP Server セットアップを開始します...\n");
+    // トークンの検証
+    if (!token || !token.startsWith("seevo_mcp_")) {
+        console.error("❌ エラー: 有効なSeevo MCPトークンを指定してください");
+        console.error("   トークンは 'seevo_mcp_' で始まる必要があります\n");
+        process.exit(1);
+    }
+    const configPath = isGlobal
+        ? getGlobalConfigPath()
+        : join(projectPath || process.cwd(), ".mcp.json");
+    console.log(`📝 設定ファイル: ${configPath}`);
+    console.log(`🌍 スコープ: ${isGlobal ? "グローバル（全プロジェクト）" : "ローカル（このプロジェクトのみ）"}\n`);
+    // グローバル設定の場合はディレクトリを確認・作成
+    if (isGlobal) {
+        const configDir = join(configPath, "..");
+        if (!existsSync(configDir)) {
+            console.log("📁 設定ディレクトリを作成中...");
+            mkdirSync(configDir, { recursive: true });
+        }
+    }
+    // 既存の設定を読み込む（あれば）
+    let config = {};
+    if (existsSync(configPath)) {
+        try {
+            const existingConfig = readFileSync(configPath, "utf-8");
+            config = JSON.parse(existingConfig);
+            console.log("✓ 既存の設定ファイルを読み込みました");
+        }
+        catch (error) {
+            console.warn("⚠️  既存の設定ファイルの読み込みに失敗しました。新規作成します。");
+        }
+    }
+    // mcpServersセクションがなければ作成
+    if (!config.mcpServers) {
+        config.mcpServers = {};
+    }
+    // Seevo MCPサーバーの設定を追加
+    config.mcpServers.seevo = {
+        command: "npx",
+        args: ["@zelklab/seevo-mcp-server"],
+        env: {
+            SEEVO_MCP_TOKEN: token,
+            SEEVO_API_URL: SEEVO_API_URL,
+        },
+    };
+    // 設定ファイルに書き込み
+    try {
+        writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+        console.log("✓ 設定ファイルを更新しました");
+    }
+    catch (error) {
+        console.error("❌ 設定ファイルの書き込みに失敗しました:", error);
+        process.exit(1);
+    }
+    // 完了メッセージ
+    console.log("\n" + "=".repeat(60));
+    console.log("✅ セットアップ完了！");
+    console.log("=".repeat(60));
+    console.log(`\n📍 設定ファイルの場所: ${configPath}\n`);
+    console.log("次のステップ：\n");
+    if (!isGlobal) {
+        console.log(`  1. プロジェクトのルートディレクトリで Claude Code を開いてください`);
+        console.log(`     （.mcp.json が置かれているディレクトリ）`);
+    }
+    else {
+        console.log(`  1. Claude Codeを再起動してください`);
+    }
+    console.log("  2. 以下のように話しかけてください：\n");
+    console.log('     "このプロジェクトをSeevoに登録して"\n');
+    if (!isGlobal) {
+        console.log("⚠️  重要：");
+        console.log("  • .mcp.json ファイルには認証トークンが含まれています");
+        console.log("  • このファイルを .gitignore に追加することを推奨します：");
+        console.log("    echo '.mcp.json' >> .gitignore");
+        console.log("  • または、チームで共有する場合は環境変数を使ってください\n");
+    }
+    console.log("📚 利用可能なツール：");
+    console.log("  • seevo_register_project - プロジェクトを自動解析して登録");
+    console.log("  • seevo_login - 別アカウントでログイン");
+    console.log("  • seevo_logout - ログアウト\n");
+    console.log("💡 ヒント：Claude Codeは自動的にプロジェクトを解析し、");
+    console.log("   目的、ターゲット、機能、技術スタックを理解します。\n");
+}
+// CLI実行
+const args = process.argv.slice(2);
+if (args.length === 0) {
+    console.error("❌ エラー: トークンを指定してください\n");
+    console.log("使い方:");
+    console.log("  npx @zelklab/seevo-mcp-server setup YOUR_TOKEN              # デフォルト: ローカル");
+    console.log("  npx @zelklab/seevo-mcp-server setup YOUR_TOKEN --local     # プロジェクトローカル（推奨）");
+    console.log("  npx @zelklab/seevo-mcp-server setup YOUR_TOKEN --global    # グローバル設定");
+    console.log("  npx @zelklab/seevo-mcp-server setup YOUR_TOKEN --path /path/to/project  # 別のプロジェクトに設定\n");
+    process.exit(1);
+}
+// 引数をパース
+let token = "";
+let isGlobal = false;
+let projectPath;
+// setupコマンドが含まれている場合はスキップ
+const startIndex = args[0] === "setup" ? 1 : 0;
+for (let i = startIndex; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--global") {
+        isGlobal = true;
+    }
+    else if (arg === "--local") {
+        isGlobal = false;
+    }
+    else if (arg === "--path" && args[i + 1]) {
+        projectPath = args[i + 1];
+        i++; // 次の引数をスキップ
+    }
+    else if (arg === "--token" && args[i + 1]) {
+        token = args[i + 1];
+        i++; // 次の引数をスキップ
+    }
+    else if (!arg.startsWith("--") && !token) {
+        // フラグでなく、まだトークンが設定されていない場合
+        token = arg;
+    }
+}
+if (!token) {
+    console.error("❌ エラー: トークンが見つかりません\n");
+    process.exit(1);
+}
+// グローバルとプロジェクトパスが同時に指定された場合はエラー
+if (isGlobal && projectPath) {
+    console.error("❌ エラー: --global と --path は同時に指定できません\n");
+    process.exit(1);
+}
+setupMCP(token, isGlobal, projectPath);

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@zelklab/seevo-mcp-server",
+  "version": "0.1.0",
+  "description": "MCP Server for Seevo - AI-powered project registration from Claude Code",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "seevo-mcp": "./dist/setup.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc && node dist/index.js",
+    "setup": "node dist/setup.js",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "mcp",
+    "seevo",
+    "claude-code",
+    "ai",
+    "marketing",
+    "automation"
+  ],
+  "author": "Your Name <your-email@example.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/your-username/seevo.git",
+    "directory": "mcp-server"
+  },
+  "homepage": "https://github.com/your-username/seevo#readme",
+  "bugs": {
+    "url": "https://github.com/your-username/seevo/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.6.0",
+    "node-fetch": "^3.3.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  }
+}