filebread-mcp 0.1.0

package/index.js

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+
+const readline = require("readline");
+const https = require("https");
+const http = require("http");
+
+const API_KEY = process.env.FILEBREAD_API_KEY;
+const API_URL = process.env.FILEBREAD_API_URL || "https://filebread.com";
+
+if (!API_KEY) {
+  process.stderr.write(
+    "[filebread-mcp] Error: FILEBREAD_API_KEY is required.\n" +
+      "Get your API key at https://filebread.com/settings/api-keys\n"
+  );
+  process.exit(1);
+}
+
+const TOOLS = [
+  {
+    name: "get_context",
+    description:
+      "Get optimized context from the project knowledge base. Returns the most relevant documentation, code snippets, and project knowledge for a given query. Use this to understand how things work in the project before writing code.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description:
+            "What you want to know about the project. Be specific - e.g. 'how does authentication work?' or 'what are the coding conventions?'",
+        },
+        token_budget: {
+          type: "number",
+          description:
+            "Maximum tokens to return (default: 4000, range: 500-16000).",
+        },
+      },
+      required: ["query"],
+    },
+    annotations: { readOnlyHint: true },
+  },
+  {
+    name: "search_knowledge",
+    description:
+      "Search the knowledge base for specific information. Returns matching chunks with similarity scores.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search query - can be a question, keyword, or code snippet",
+        },
+      },
+      required: ["query"],
+    },
+    annotations: { readOnlyHint: true },
+  },
+  {
+    name: "list_sources",
+    description:
+      "List all indexed knowledge sources (files and documents) available in the project.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+    },
+    annotations: { readOnlyHint: true },
+  },
+];
+
+// --- HTTP client (zero dependencies) ---
+
+function apiRequest(method, path, body) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(path, API_URL);
+    const mod = url.protocol === "https:" ? https : http;
+
+    const options = {
+      hostname: url.hostname,
+      port: url.port || (url.protocol === "https:" ? 443 : 80),
+      path: url.pathname,
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY,
+      },
+    };
+
+    const req = mod.request(options, (res) => {
+      let data = "";
+      res.on("data", (chunk) => (data += chunk));
+      res.on("end", () => {
+        try {
+          resolve({ status: res.statusCode, body: JSON.parse(data) });
+        } catch {
+          resolve({ status: res.statusCode, body: data });
+        }
+      });
+    });
+
+    req.on("error", reject);
+    req.setTimeout(30000, () => {
+      req.destroy();
+      reject(new Error("Request timeout"));
+    });
+
+    if (body) req.write(JSON.stringify(body));
+    req.end();
+  });
+}
+
+// --- Tool handlers ---
+
+async function handleGetContext(args) {
+  const payload = { query: args.query };
+  if (args.token_budget) payload.token_budget = args.token_budget;
+
+  const res = await apiRequest("POST", "/api/v1/context", payload);
+
+  if (res.status !== 200) {
+    return { text: `Error (${res.status}): ${JSON.stringify(res.body)}`, isError: true };
+  }
+
+  const { context, metadata } = res.body;
+
+  let text = `## Context for: ${metadata.query}\n`;
+  text += `Intent: ${metadata.intent} | Tokens: ${metadata.tokens_used}/${metadata.token_budget} | `;
+  text += `Score: ${metadata.evaluation_score} | Sources: ${metadata.chunks_returned}\n\n`;
+
+  if (!context || context.length === 0) {
+    text += "No relevant context found for this query.";
+  } else {
+    text += context
+      .map((item) => {
+        const source = item.source?.name ? `**Source: ${item.source.name}** (relevance: ${item.relevance_score})\n\n` : "";
+        return source + item.content;
+      })
+      .join("\n---\n\n");
+  }
+
+  return { text };
+}
+
+async function handleSearchKnowledge(args) {
+  const res = await apiRequest("POST", "/api/search", { query: args.query });
+
+  if (res.status !== 200) {
+    return { text: `Error (${res.status}): ${JSON.stringify(res.body)}`, isError: true };
+  }
+
+  const results = res.body.results || res.body;
+
+  if (!Array.isArray(results) || results.length === 0) {
+    return { text: "No results found." };
+  }
+
+  const text = results
+    .map((r) => {
+      const name = r.source_name || r.file_name || "unknown";
+      const score = r.similarity || r.score || 0;
+      return `**${name}** (score: ${Number(score).toFixed(2)})\n${r.content || r.text || ""}`;
+    })
+    .join("\n---\n\n");
+
+  return { text };
+}
+
+async function handleListSources() {
+  const res = await apiRequest("GET", "/api/files", null);
+
+  if (res.status !== 200) {
+    return { text: `Error (${res.status}): ${JSON.stringify(res.body)}`, isError: true };
+  }
+
+  const files = res.body.files || [];
+
+  if (files.length === 0) {
+    return { text: "No indexed files found. Upload files or connect a source at filebread.com" };
+  }
+
+  let text = `## Indexed Sources (${files.length} files)\n\n`;
+  text += files
+    .map((f) => `- **${f.original_name}** (${f.content_type})`)
+    .join("\n");
+
+  return { text };
+}
+
+// --- MCP Protocol ---
+
+function handleMessage(msg) {
+  const { method, id, params = {} } = msg;
+
+  if (method === "initialize") {
+    return respond(id, {
+      protocolVersion: "2025-03-26",
+      capabilities: { tools: { listChanged: false } },
+      serverInfo: { name: "filebread", version: "0.1.0" },
+      instructions:
+        "FileBread provides optimized project context for AI coding agents. Use get_context to retrieve relevant documentation and knowledge before writing code.",
+    });
+  }
+
+  if (method === "notifications/initialized") return;
+
+  if (method === "tools/list") {
+    return respond(id, { tools: TOOLS });
+  }
+
+  if (method === "tools/call") {
+    return handleToolCall(id, params.name, params.arguments || {});
+  }
+
+  if (method === "ping") {
+    return respond(id, {});
+  }
+
+  return respondError(id, -32601, `Method not found: ${method}`);
+}
+
+async function handleToolCall(id, name, args) {
+  try {
+    let result;
+
+    switch (name) {
+      case "get_context":
+        if (!args.query) return respondError(id, -32602, "Missing required parameter: query");
+        result = await handleGetContext(args);
+        break;
+      case "search_knowledge":
+        if (!args.query) return respondError(id, -32602, "Missing required parameter: query");
+        result = await handleSearchKnowledge(args);
+        break;
+      case "list_sources":
+        result = await handleListSources();
+        break;
+      default:
+        return respondError(id, -32602, `Unknown tool: ${name}`);
+    }
+
+    respond(id, {
+      content: [{ type: "text", text: result.text }],
+      ...(result.isError && { isError: true }),
+    });
+  } catch (err) {
+    respond(id, {
+      content: [{ type: "text", text: `Error: ${err.message}` }],
+      isError: true,
+    });
+  }
+}
+
+function respond(id, result) {
+  const msg = JSON.stringify({ jsonrpc: "2.0", id, result });
+  process.stdout.write(msg + "\n");
+}
+
+function respondError(id, code, message) {
+  const msg = JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } });
+  process.stdout.write(msg + "\n");
+}
+
+// --- Main loop ---
+
+const rl = readline.createInterface({ input: process.stdin });
+
+rl.on("line", (line) => {
+  try {
+    const msg = JSON.parse(line.trim());
+    handleMessage(msg);
+  } catch (err) {
+    process.stderr.write(`[filebread-mcp] Parse error: ${err.message}\n`);
+  }
+});
+
+rl.on("close", () => process.exit(0));

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "filebread-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for FileBread - give AI agents context about your project",
+  "bin": {
+    "filebread-mcp": "./index.js"
+  },
+  "keywords": ["mcp", "context", "ai", "claude", "cursor", "rag"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/FileBread/file_bread"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": ["index.js"]
+}