@bridge_gpt/mcp-server 0.1.4 → 0.1.6

package/README.md

@@ -9,6 +9,7 @@ MCP server for [Bridge API](https://bridgegpt-api.com) — exposes Jira integrat
 | `BAPI_BASE_URL` | Yes | `https://bridgegpt-api.com` | Bridge API base URL |
 | `BAPI_REPO_NAME` | Yes | _(none)_ | Jira project/repository identifier configured in Bridge API |
 | `BAPI_API_KEY` | Yes | _(none)_ | API key obtained from the Bridge API setup UI |
+| `BAPI_PROJECT_ROOT` | No | _(auto-set by --init)_ | Absolute path to project root. Anchors BAPI_DOCS_DIR and BAPI_PIPELINES_DIR resolution. Set automatically by --init. |
 | `BAPI_DOCS_DIR` | No | `docs/tmp` | Local directory for saving plans, critiques, and research reports |
 | `BAPI_PIPELINES_DIR` | No | `.bridge/pipelines` | Directory for user-defined custom pipeline JSON files |
 
@@ -62,7 +63,7 @@ claude mcp add bridge-api -- npx -y @bridge_gpt/mcp-server \
 }
 ```
 
-### Cursor (~/.cursor/config/mcp.json)
+### Cursor (.cursor/mcp.json — project-local)
 
 ```json
 {
@@ -81,8 +82,12 @@ claude mcp add bridge-api -- npx -y @bridge_gpt/mcp-server \
 }
 ```
 
+> **Global fallback:** If project-local config is not supported in your Cursor version, use `~/.cursor/config/mcp.json` instead.
+
 ### Windsurf (~/.codeium/windsurf/mcp_config.json)
 
+> **Note:** Windsurf only supports global MCP configuration. `--init` detects Windsurf projects and outputs a ready-to-paste config snippet to the console.
+
 ```json
 {
   "mcpServers": {
@@ -122,7 +127,17 @@ Bridge API ships pre-built slash commands for Claude Code and Cursor. To scaffol
 npx @bridge_gpt/mcp-server --init
 ```
 
-This writes command files to `.claude/commands/` and `.cursor/commands/` in your current directory. Re-run after upgrading the package to get updated commands.
+Run from your project root. `--init` performs the following:
+
+1. **IDE detection** — checks for `.vscode/`, `.cursor/`, `.windsurf/`, and `.windsurfrules` to determine which IDEs are in use.
+2. **MCP config files** — creates or updates `.mcp.json`, `.vscode/mcp.json`, and `.cursor/mcp.json` with sensible defaults and placeholder values (`YOUR_API_KEY`, `YOUR_REPO_NAME`). Only creates IDE-specific configs when that IDE is detected. Existing configs are preserved — only the `bridge-api` entry is added or updated.
+3. **Gitignore** — newly created config files are automatically added to `.gitignore` to prevent committing API key placeholders.
+4. **Slash commands** — writes command files to `.claude/commands/` (always) and `.cursor/commands/` (when Cursor is detected).
+5. **Windsurf** — since Windsurf only supports global config, outputs a ready-to-paste JSON snippet to the console.
+
+Re-run after upgrading the package to get updated commands. Replace placeholder values (`YOUR_API_KEY`, `YOUR_REPO_NAME`) with your actual credentials from the Bridge API setup UI.
+
+> **Codex users:** `--init` does not modify `~/.codex/config.toml`. Set `BAPI_PROJECT_ROOT` manually in your Codex MCP config.
 
 ## Available Tools
 

package/build/index.js

@@ -27,8 +27,9 @@ let userPipelineKeys = new Set();
 const BASE_URL = process.env.BAPI_BASE_URL ?? "https://bridgegpt-api.com";
 const REPO_NAME = process.env.BAPI_REPO_NAME ?? "";
 const API_KEY = process.env.BAPI_API_KEY ?? "";
-const BAPI_DOCS_DIR = path.resolve(process.cwd(), process.env.BAPI_DOCS_DIR ?? "docs/tmp");
-const BAPI_PIPELINES_DIR = path.resolve(process.cwd(), process.env.BAPI_PIPELINES_DIR ?? ".bridge/pipelines");
+const PROJECT_ROOT = process.env.BAPI_PROJECT_ROOT ?? process.cwd();
+const BAPI_DOCS_DIR = path.resolve(PROJECT_ROOT, process.env.BAPI_DOCS_DIR ?? "docs/tmp");
+const BAPI_PIPELINES_DIR = path.resolve(PROJECT_ROOT, process.env.BAPI_PIPELINES_DIR ?? ".bridge/pipelines");
 const GET_HEADERS = { "X-API-Key": API_KEY };
 const POST_HEADERS = {
     "X-API-Key": API_KEY,
@@ -205,19 +206,164 @@ async function pollForResult(getUrl, timeoutMs, label) {
     }
 }
 // ---------------------------------------------------------------------------
-// CLI: --init scaffolds slash commands into the current project
+// CLI: --init scaffolds slash commands and MCP configs into the current project
 // ---------------------------------------------------------------------------
+function buildBridgeApiEntry(cwd) {
+    return {
+        command: "npx",
+        args: ["-y", "@bridge_gpt/mcp-server"],
+        env: {
+            BAPI_BASE_URL: "https://bridgegpt-api.com",
+            BAPI_REPO_NAME: "YOUR_REPO_NAME",
+            BAPI_API_KEY: "YOUR_API_KEY",
+            BAPI_DOCS_DIR: "docs/tmp",
+            BAPI_PROJECT_ROOT: cwd,
+        },
+    };
+}
+async function ensureGitignored(cwd, filePath) {
+    const gitignorePath = path.join(cwd, ".gitignore");
+    const entry = filePath.startsWith("/") ? path.relative(cwd, filePath) : filePath;
+    let content = "";
+    try {
+        content = await readFile(gitignorePath, "utf-8");
+    }
+    catch { /* .gitignore doesn't exist yet */ }
+    // Check if already present (exact line match)
+    const lines = content.split("\n");
+    if (lines.some((line) => line.trim() === entry))
+        return;
+    const separator = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
+    await writeFile(gitignorePath, content + separator + entry + "\n", "utf-8");
+}
 if (process.argv.includes("--init")) {
+    // Guard: must be run from project root
+    try {
+        await stat(path.join(process.cwd(), "package.json"));
+    }
+    catch {
+        console.error("Error: No package.json found in current directory.\n" +
+            "--init must be run from your project root (the directory containing package.json).");
+        process.exit(1);
+    }
     try {
         const cwd = process.cwd();
-        const dirs = [
-            path.join(cwd, ".claude", "commands"),
-            path.join(cwd, ".cursor", "commands"),
+        // ---- Phase 1: IDE Detection ----
+        const ideDetection = {
+            claude: true,
+            vscode: false,
+            cursor: false,
+            windsurf: false,
+        };
+        try {
+            await stat(path.join(cwd, ".vscode"));
+            ideDetection.vscode = true;
+        }
+        catch { }
+        try {
+            await stat(path.join(cwd, ".cursor"));
+            ideDetection.cursor = true;
+        }
+        catch { }
+        if (!ideDetection.cursor && process.env.CURSOR_TRACE_DIR)
+            ideDetection.cursor = true;
+        try {
+            await stat(path.join(cwd, ".windsurf"));
+            ideDetection.windsurf = true;
+        }
+        catch { }
+        if (!ideDetection.windsurf) {
+            try {
+                await stat(path.join(cwd, ".windsurfrules"));
+                ideDetection.windsurf = true;
+            }
+            catch { }
+        }
+        const detectedIDEs = Object.entries(ideDetection)
+            .filter(([, v]) => v)
+            .map(([k]) => k);
+        console.log(`Bridge API --init: detected IDEs: ${detectedIDEs.join(", ")}`);
+        // ---- Phase 2: Windsurf manual instructions ----
+        if (ideDetection.windsurf) {
+            const windsurfSnippet = JSON.stringify({ mcpServers: { "bridge-api": buildBridgeApiEntry(cwd) } }, null, 2);
+            console.log("\n⚠ Windsurf does not support project-local MCP configuration.\n" +
+                "Add the following to ~/.codeium/windsurf/mcp_config.json:\n\n" +
+                windsurfSnippet + "\n");
+        }
+        // ---- Phase 3: Config file handling ----
+        const configTargets = [
+            { path: ".mcp.json", topLevelKey: "mcpServers", shouldCreate: true },
+            { path: ".vscode/mcp.json", topLevelKey: "servers", shouldCreate: ideDetection.vscode },
+            { path: ".cursor/mcp.json", topLevelKey: "mcpServers", shouldCreate: ideDetection.cursor },
         ];
+        const configActions = [];
+        let anyCreatedOrAdded = false;
+        for (const target of configTargets) {
+            const fullPath = path.join(cwd, target.path);
+            let fileExists = false;
+            try {
+                await stat(fullPath);
+                fileExists = true;
+            }
+            catch { }
+            if (!target.shouldCreate && !fileExists) {
+                configActions.push({ path: target.path, action: "skipped — IDE not detected" });
+                continue;
+            }
+            if (fileExists) {
+                // Read and parse existing file
+                const raw = await readFile(fullPath, "utf-8");
+                let parsed;
+                try {
+                    parsed = JSON.parse(raw);
+                }
+                catch {
+                    console.warn(`  ${target.path} skipped — invalid JSON format`);
+                    configActions.push({ path: target.path, action: "skipped — invalid JSON" });
+                    continue;
+                }
+                const topLevel = parsed[target.topLevelKey];
+                if (topLevel && topLevel["bridge-api"]) {
+                    // Entry exists — update BAPI_PROJECT_ROOT only
+                    if (!topLevel["bridge-api"].env)
+                        topLevel["bridge-api"].env = {};
+                    topLevel["bridge-api"].env.BAPI_PROJECT_ROOT = cwd;
+                    await writeFile(fullPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+                    configActions.push({ path: target.path, action: "updated BAPI_PROJECT_ROOT" });
+                }
+                else {
+                    // Entry missing — add it, preserving existing content
+                    if (!parsed[target.topLevelKey])
+                        parsed[target.topLevelKey] = {};
+                    parsed[target.topLevelKey]["bridge-api"] = buildBridgeApiEntry(cwd);
+                    await writeFile(fullPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+                    configActions.push({ path: target.path, action: "added entry" });
+                    anyCreatedOrAdded = true;
+                }
+            }
+            else {
+                // Create new file
+                await mkdir(path.dirname(fullPath), { recursive: true });
+                const content = { [target.topLevelKey]: { "bridge-api": buildBridgeApiEntry(cwd) } };
+                await writeFile(fullPath, JSON.stringify(content, null, 2) + "\n", "utf-8");
+                await ensureGitignored(cwd, target.path);
+                configActions.push({ path: target.path, action: "created" });
+                anyCreatedOrAdded = true;
+            }
+        }
+        console.log("\nMCP config files:");
+        for (const entry of configActions) {
+            console.log(`  ${entry.path}: ${entry.action}`);
+        }
+        // ---- Phase 4: Scaffold slash command directories ----
+        const commandDirs = [path.join(cwd, ".claude", "commands")];
+        if (ideDetection.cursor) {
+            commandDirs.push(path.join(cwd, ".cursor", "commands"));
+        }
         const writtenFiles = new Set();
         const skippedFiles = new Set();
         const overwrittenFiles = new Set();
-        for (const dir of dirs) {
+        for (const dir of commandDirs) {
             await mkdir(dir, { recursive: true });
             for (const [filename, content] of Object.entries(COMMANDS)) {
                 const target = path.join(dir, filename);
@@ -238,17 +384,18 @@ if (process.argv.includes("--init")) {
         for (const f of writtenFiles)
             skippedFiles.delete(f);
         const total = Object.keys(COMMANDS).length;
-        console.log(`Bridge API: scaffolded ${total} commands into ${dirs.length} directories`);
+        const dirNames = commandDirs.map((d) => path.relative(cwd, d)).join(" and ");
+        console.log(`\nSlash commands: scaffolded ${total} commands into ${commandDirs.length} director${commandDirs.length === 1 ? "y" : "ies"}`);
         if (writtenFiles.size > 0)
             console.log(`  Written: ${writtenFiles.size}`);
         if (overwrittenFiles.size > 0)
             console.log(`  Overwritten (content changed): ${overwrittenFiles.size}`);
         if (skippedFiles.size > 0)
             console.log(`  Skipped (unchanged): ${skippedFiles.size}`);
-        console.log(`  .claude/commands/ and .cursor/commands/`);
-        // Scaffold custom pipeline directories
-        const pipelinesDir = BAPI_PIPELINES_DIR;
-        const instrDir = path.join(path.dirname(BAPI_PIPELINES_DIR), "instructions");
+        console.log(`  ${dirNames}`);
+        // ---- Phase 5: Scaffold custom pipeline directories ----
+        const pipelinesDir = path.resolve(cwd, process.env.BAPI_PIPELINES_DIR ?? ".bridge/pipelines");
+        const instrDir = path.join(path.dirname(pipelinesDir), "instructions");
         await mkdir(pipelinesDir, { recursive: true });
         await mkdir(instrDir, { recursive: true });
         const readmePath = path.join(pipelinesDir, "README.md");
@@ -369,6 +516,11 @@ automatically provided by the server.
             console.log(`  ${path.relative(cwd, examplePath)} (written)`);
         }
         console.log(`  ${path.relative(cwd, instrDir)}/ (ensured)`);
+        // ---- Phase 6: Final summary ----
+        if (anyCreatedOrAdded) {
+            console.log("\nUpdate BAPI_API_KEY and BAPI_REPO_NAME in your config files — " +
+                "get these values from the Bridge API setup UI at https://bridgegpt-api.com");
+        }
         process.exit(0);
     }
     catch (err) {
@@ -1116,7 +1268,7 @@ server.registerTool("request_ticket_critique", {
     }
     const confirmationText = `Ticket critique requested for ${ticket_number}. ` +
         `Processing typically takes 1-5 minutes. ` +
-        `Use get_critique with ticket_number "${ticket_number}" to retrieve the results once processing completes.`;
+        `Use get_ticket_critique with ticket_number "${ticket_number}" to retrieve the results once processing completes.`;
     return { content: [{ type: "text", text: confirmationText }] };
 });
 // ---------------------------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bridge_gpt/mcp-server",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Bridge API MCP server — exposes Jira endpoints as MCP tools for Claude Code agents",
   "license": "MIT",
   "type": "module",