flowseeker 0.1.7

package/dist/cli/mcpServer.js

@@ -0,0 +1,383 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * FlowSeeker Standalone MCP Server (stdio transport).
+ *
+ * Run with:
+ *   node dist/cli/mcpServer.js [--workspace /path/to/repo]
+ *
+ * Or via npx (after publishing): package name is `flowseeker`, bin is `flowseeker-mcp`:
+ *   npx -p flowseeker flowseeker-mcp --workspace /path/to/repo
+ *
+ * This server implements the Model Context Protocol (MCP) over stdio,
+ * exposing FlowSeeker's retrieval pipeline as tools that any MCP-compliant
+ * client can invoke (Cursor, Antigravity, Windsurf, Claude Desktop, etc.).
+ *
+ * Protocol: JSON-RPC 2.0 over stdin/stdout, one JSON object per line.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const readline = __importStar(require("readline"));
+const mcpTools_1 = require("../mcp/mcpTools");
+const updateChecker_1 = require("../utils/updateChecker");
+const SERVER_NAME = "flowseeker-mcp";
+const SERVER_VERSION = "0.1.7";
+const PROTOCOL_VERSION = "2024-11-05";
+function parseCliArgs(argv) {
+    let workspace = process.cwd();
+    let mode = "server";
+    for (let i = 0; i < argv.length; i++) {
+        if ((argv[i] === "--workspace" || argv[i] === "-w") && argv[i + 1]) {
+            workspace = argv[i + 1];
+            i++;
+            continue;
+        }
+        if (argv[i] === "--version" || argv[i] === "-v") {
+            mode = "version";
+            continue;
+        }
+        if (argv[i] === "--check-updates") {
+            mode = "check-updates";
+            continue;
+        }
+        if (argv[i] === "--help" || argv[i] === "-h") {
+            printHelp();
+            process.exit(0);
+        }
+    }
+    return { workspace, mode };
+}
+function printHelp() {
+    const help = [
+        "FlowSeeker MCP Server — expose codebase retrieval as MCP tools.",
+        "",
+        "Usage (installed via npm):",
+        "  npx -p flowseeker flowseeker-mcp [options]",
+        "",
+        "Usage (local dev build):",
+        "  node dist/cli/mcpServer.js [options]",
+        "",
+        "Options:",
+        "  --workspace, -w <path>  Workspace root path (default: cwd)",
+        "  --version, -v          Print version and exit",
+        "  --check-updates        Check npm for a newer FlowSeeker version and exit",
+        "  --help, -h             Show this help",
+        "",
+        "This server communicates via JSON-RPC 2.0 over stdin/stdout.",
+        "Configure it as an MCP server in your IDE or AI client.",
+        "",
+        "Cursor/Antigravity/Windsurf/Claude Desktop config (npx):",
+        '  {',
+        '    "mcpServers": {',
+        '      "flowseeker": {',
+        '        "command": "npx",',
+        '        "args": ["-p", "flowseeker", "flowseeker-mcp", "--workspace", "."]',
+        '      }',
+        '    }',
+        '  }',
+        "",
+        "VS Code / Copilot .vscode/mcp.json config:",
+        '  {',
+        '    "servers": {',
+        '      "flowseeker": {',
+        '        "command": "npx",',
+        '        "args": ["-p", "flowseeker", "flowseeker-mcp", "--workspace", "."]',
+        '      }',
+        '    }',
+        '  }',
+        "",
+        "Native Chat autocomplete is controlled by the IDE host; FlowSeeker exposes tools and prompts via MCP.",
+        "",
+        "Dev / local build alternative:",
+        '  {',
+        '    "mcpServers": {',
+        '      "flowseeker": {',
+        '        "command": "node",',
+        '        "args": ["path/to/dist/cli/mcpServer.js", "--workspace", "."]',
+        '      }',
+        '    }',
+        '  }',
+        "",
+        "For per-IDE setup instructions visit:",
+        "  https://www.npmjs.com/package/flowseeker",
+        ""
+    ];
+    console.error(help.join("\n"));
+}
+// ── MCP Protocol Handlers ─────────────────────────────────────────────
+function handleInitialize(_params) {
+    return {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: {
+            tools: { listChanged: true },
+            prompts: { listChanged: true }
+        },
+        serverInfo: {
+            name: SERVER_NAME,
+            version: SERVER_VERSION
+        }
+    };
+}
+function handleToolsList() {
+    return {
+        tools: mcpTools_1.TOOL_DEFINITIONS.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema
+        }))
+    };
+}
+function handlePromptsList() {
+    return {
+        prompts: mcpTools_1.MCP_PROMPT_DEFINITIONS.map((prompt) => ({
+            name: prompt.name,
+            description: prompt.description,
+            arguments: prompt.arguments
+        }))
+    };
+}
+function handlePromptsGet(params) {
+    const name = params.name;
+    const prompt = mcpTools_1.MCP_PROMPT_DEFINITIONS.find((candidate) => candidate.name === name);
+    if (!prompt) {
+        throw new Error(`Unknown prompt: ${name}`);
+    }
+    const args = (params.arguments ?? {});
+    const task = typeof args.task === "string" && args.task.trim() ? args.task.trim() : "<describe your task>";
+    const workspace = typeof args.workspace === "string" && args.workspace.trim()
+        ? ` Workspace: ${args.workspace.trim()}.`
+        : "";
+    return {
+        description: prompt.description,
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `Use the ${prompt.toolName} MCP tool to ${prompt.toolPurpose}. Task: ${task}.${workspace}`
+                }
+            }
+        ]
+    };
+}
+async function handleToolsCall(params, defaultWorkspace) {
+    const name = params.name;
+    const args = (params.arguments ?? {});
+    if (!name) {
+        return {
+            content: [{ type: "text", text: "Missing tool name." }],
+            isError: true
+        };
+    }
+    return (0, mcpTools_1.handleToolCall)(name, args, defaultWorkspace);
+}
+// ── Main Server Loop ──────────────────────────────────────────────────
+let pendingCalls = 0;
+let initialized = false;
+async function processRequest(request, workspace) {
+    const { id, method, params } = request;
+    // Notifications (no id) — just acknowledge
+    if (id === undefined || id === null) {
+        if (method === "notifications/initialized") {
+            logStderr("Client initialized.");
+            initialized = true;
+        }
+        return null; // Notifications don't get responses
+    }
+    try {
+        let result;
+        switch (method) {
+            case "initialize":
+                result = handleInitialize(params ?? {});
+                break;
+            case "tools/list":
+                result = handleToolsList();
+                break;
+            case "tools/call":
+                pendingCalls++;
+                try {
+                    result = await handleToolsCall(params ?? {}, workspace);
+                }
+                finally {
+                    pendingCalls--;
+                }
+                break;
+            case "prompts/list":
+                result = handlePromptsList();
+                break;
+            case "prompts/get":
+                result = handlePromptsGet(params ?? {});
+                break;
+            case "ping":
+                result = {};
+                break;
+            default:
+                return {
+                    jsonrpc: "2.0",
+                    id,
+                    error: {
+                        code: -32601,
+                        message: `Method not found: ${method}`
+                    }
+                };
+        }
+        return { jsonrpc: "2.0", id, result };
+    }
+    catch (error) {
+        pendingCalls--;
+        const message = error instanceof Error ? error.message : String(error);
+        logStderr(`Error handling ${method}: ${message}`);
+        return {
+            jsonrpc: "2.0",
+            id,
+            error: {
+                code: -32603,
+                message: `Internal error: ${message}`
+            }
+        };
+    }
+}
+function logStderr(message) {
+    process.stderr.write(`[${SERVER_NAME}] ${message}\n`);
+}
+function sendResponse(response) {
+    process.stdout.write(JSON.stringify(response) + "\n");
+}
+async function main() {
+    const { workspace, mode } = parseCliArgs(process.argv.slice(2));
+    if (mode === "version") {
+        process.stdout.write(`${SERVER_VERSION}\n`);
+        return;
+    }
+    if (mode === "check-updates") {
+        const result = await (0, updateChecker_1.checkForPackageUpdate)(SERVER_VERSION);
+        if (result.error) {
+            process.stdout.write(`Unable to check for updates: ${result.error}\n`);
+        }
+        else if (result.hasUpdate && result.latestVersion) {
+            process.stdout.write(`FlowSeeker ${result.latestVersion} is available. Current version: ${result.currentVersion}.\n`);
+        }
+        else {
+            process.stdout.write(`FlowSeeker ${result.currentVersion} is up to date.\n`);
+        }
+        return;
+    }
+    logStderr(`FlowSeeker MCP Server v${SERVER_VERSION}`);
+    logStderr(`Workspace: ${workspace}`);
+    logStderr(`Protocol: ${PROTOCOL_VERSION}`);
+    logStderr("Listening for JSON-RPC requests on stdin...");
+    const rl = readline.createInterface({
+        input: process.stdin,
+        terminal: false
+    });
+    let buffer = "";
+    rl.on("line", async (line) => {
+        buffer += line;
+        // Try to parse complete JSON objects
+        try {
+            const request = JSON.parse(buffer);
+            buffer = "";
+            if (request.jsonrpc !== "2.0") {
+                logStderr(`Invalid JSON-RPC version: ${request.jsonrpc}`);
+                if (request.id !== undefined && request.id !== null) {
+                    sendResponse({
+                        jsonrpc: "2.0",
+                        id: request.id,
+                        error: { code: -32600, message: "Invalid Request: expected jsonrpc 2.0" }
+                    });
+                }
+                return;
+            }
+            logStderr(`← ${request.method}${request.id !== undefined ? ` (id: ${request.id})` : ""}`);
+            const response = await processRequest(request, workspace);
+            if (response) {
+                logStderr(`→ ${request.method} response sent`);
+                sendResponse(response);
+                // After initialize, send the required initialized notification
+                if (request.method === "initialize") {
+                    process.stdout.write(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }) + "\n");
+                    logStderr("→ notifications/initialized sent");
+                }
+            }
+        }
+        catch (parseError) {
+            // If it's a JSON parse error, the buffer might need more data
+            // But since we read line by line and MCP sends one object per line,
+            // a parse error here means invalid input
+            if (buffer.trim()) {
+                logStderr(`Parse error, resetting buffer. Input: ${buffer.slice(0, 200)}`);
+                buffer = "";
+            }
+        }
+    });
+    rl.on("close", () => {
+        logStderr("stdin closed. Waiting for in-flight calls to complete...");
+        const shutdown = () => {
+            logStderr("Shutting down.");
+            process.exit(0);
+        };
+        if (pendingCalls === 0) {
+            shutdown();
+            return;
+        }
+        // Wait up to 30s for pending calls, then force-exit
+        const timer = setTimeout(() => {
+            logStderr(`Force shutdown after timeout (${pendingCalls} call(s) still pending).`);
+            process.exit(0);
+        }, 30000);
+        const poll = setInterval(() => {
+            if (pendingCalls === 0) {
+                clearInterval(poll);
+                clearTimeout(timer);
+                shutdown();
+            }
+        }, 200);
+    });
+    // Handle graceful shutdown
+    process.on("SIGINT", () => {
+        logStderr("SIGINT received. Shutting down.");
+        process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+        logStderr("SIGTERM received. Shutting down.");
+        process.exit(0);
+    });
+}
+void main().catch((error) => {
+    const message = error instanceof Error ? error.stack ?? error.message : String(error);
+    process.stderr.write(`[${SERVER_NAME}] Fatal: ${message}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=mcpServer.js.map