@costlens/mcp-server 0.4.1 → 0.4.2

package/dist/cli.js

@@ -1,31 +1,407 @@
 #!/usr/bin/env node
 "use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+function resolveApiKey() {
+  const envKey = process.env.COSTLENS_API_KEY || process.env.COSTLENS_MCP_KEY || process.argv.find((a) => a.startsWith("--api-key="))?.split("=")[1];
+  if (envKey) return envKey;
+  try {
+    const config = JSON.parse((0, import_fs.readFileSync)((0, import_path.join)((0, import_os.homedir)(), ".costlens", "config.json"), "utf-8"));
+    return config.apiKey;
+  } catch {
+    return void 0;
+  }
+}
+async function loadPricing() {
+  try {
+    const headers = {};
+    if (API_KEY) headers["Authorization"] = `Bearer ${API_KEY}`;
+    const res = await fetch(`${API_BASE}/v1/pricing`, { headers, signal: AbortSignal.timeout(5e3) });
+    if (res.ok) {
+      const data = await res.json();
+      for (const m of data.models) {
+        import_classifier.PRICING[m.model] = { input: m.input, output: m.output };
+      }
+    }
+  } catch {
+  }
+}
+function startHeartbeat(sessionId) {
+  stopHeartbeat();
+  activeSessionId = sessionId;
+  heartbeatInterval = setInterval(async () => {
+    if (!activeSessionId || !API_KEY) return;
+    try {
+      const res = await fetch(`${API_BASE}/v1/productivity/heartbeat`, {
+        method: "POST",
+        headers: { "Authorization": `Bearer ${API_KEY}`, "Content-Type": "application/json" },
+        body: JSON.stringify({ session_id: activeSessionId }),
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (res.status === 410) {
+        activeSessionId = null;
+        stopHeartbeat();
+      }
+    } catch {
+    }
+  }, 6e4);
+}
+function stopHeartbeat() {
+  if (heartbeatInterval) {
+    clearInterval(heartbeatInterval);
+    heartbeatInterval = null;
+  }
+}
+async function syncEvent(result, params) {
+  try {
+    await fetch(`${API_BASE}/v1/classifier/events`, {
+      method: "POST",
+      headers: { "Authorization": `Bearer ${API_KEY}`, "Content-Type": "application/json" },
+      body: JSON.stringify({
+        complexity: result.level,
+        confidence: result.confidence,
+        suggestedModel: result.suggestedModel,
+        currentModel: params.currentModel,
+        provider: params.provider,
+        staticScore: result.signals.staticScore
+      }),
+      signal: AbortSignal.timeout(5e3)
+    });
+  } catch {
+  }
+}
+async function checkFeature(feature) {
+  if (!API_KEY) return false;
+  try {
+    const res = await fetch(`${API_BASE}/v1/plan`, {
+      headers: { "Authorization": `Bearer ${API_KEY}` },
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!res.ok) return false;
+    const plan = await res.json();
+    return plan.features?.includes(feature) ?? false;
+  } catch {
+    return false;
+  }
+}
+async function ensureProductivity() {
+  if (!API_KEY) return "Not connected to CostLens. Run: npx @costlens/mcp-server setup";
+  if (productivityEnabled === null) {
+    productivityEnabled = await checkFeature("productivity_basic");
+  }
+  if (!productivityEnabled) return "Productivity tracking requires Business plan or Productivity add-on.";
+  return null;
+}
+async function main() {
+  await loadPricing();
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+  const cleanup = async () => {
+    if (activeSessionId && API_KEY) {
+      try {
+        await fetch(`${API_BASE}/v1/productivity/sessions/${activeSessionId}`, {
+          method: "PATCH",
+          headers: { "Authorization": `Bearer ${API_KEY}`, "Content-Type": "application/json" },
+          body: JSON.stringify({ outcome: "completed" }),
+          signal: AbortSignal.timeout(3e3)
+        });
+      } catch {
+      }
+    }
+    stopHeartbeat();
+    process.exit(0);
+  };
+  process.on("SIGTERM", cleanup);
+  process.on("SIGINT", cleanup);
+}
+var import_mcp, import_stdio, import_zod, import_classifier, import_fs, import_path, import_os, API_KEY, API_BASE, server, activeSessionId, heartbeatInterval, productivityEnabled;
+var init_index = __esm({
+  "src/index.ts"() {
+    "use strict";
+    import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+    import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+    import_zod = require("zod");
+    import_classifier = require("@lens360/classifier");
+    import_fs = require("fs");
+    import_path = require("path");
+    import_os = require("os");
+    API_KEY = resolveApiKey();
+    API_BASE = process.env.COSTLENS_API_URL || "https://api.costlens.dev";
+    server = new import_mcp.McpServer({
+      name: "@lens360/mcp-server",
+      version: "0.3.1"
+    });
+    activeSessionId = null;
+    heartbeatInterval = null;
+    server.tool(
+      "get_spend_summary",
+      "Get current spend summary \u2014 daily, weekly, monthly, and session totals",
+      {},
+      async () => {
+        if (!API_KEY) {
+          return { content: [{ type: "text", text: "Not connected to CostLens. Run: npx @costlens/mcp-server setup" }] };
+        }
+        try {
+          const res = await fetch(`${API_BASE}/v1/spend`, {
+            headers: { "Authorization": `Bearer ${API_KEY}` },
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok) {
+            return { content: [{ type: "text", text: `Error: ${res.status} \u2014 ${await res.text()}` }] };
+          }
+          const data = await res.json();
+          const lines = [
+            `\u{1F4B0} Spend Summary (${data.key})`,
+            ``,
+            `Today:   $${data.daily.cost.toFixed(4)} (${data.daily.requests} requests)`,
+            `Week:    $${data.weekly.cost.toFixed(4)} (${data.weekly.requests} requests)`,
+            `Month:   $${data.monthly.cost.toFixed(4)} (${data.monthly.requests} requests)`
+          ];
+          if (data.session) {
+            lines.push(`Session: $${data.session.cost.toFixed(4)} (${data.session.requests} requests) [${data.session.correlationId}]`);
+          }
+          if (data.dailyBudget) {
+            lines.push(``, `Budget:  $${data.budgetRemaining.toFixed(2)} remaining of $${data.dailyBudget.toFixed(2)}/day`);
+          }
+          return { content: [{ type: "text", text: lines.join("\n") }] };
+        } catch (err) {
+          return { content: [{ type: "text", text: `Error fetching spend: ${err.message}` }] };
+        }
+      }
+    );
+    server.tool(
+      "costlens_suggest_model",
+      "Analyze a prompt and suggest the cheapest adequate model",
+      {
+        prompt: import_zod.z.string(),
+        currentModel: import_zod.z.string(),
+        provider: import_zod.z.string(),
+        messageCount: import_zod.z.number().optional(),
+        routingMode: import_zod.z.string().optional(),
+        isFirstMessage: import_zod.z.boolean().optional()
+      },
+      async (params) => {
+        const result = (0, import_classifier.classify)({
+          prompt: params.prompt,
+          currentModel: params.currentModel,
+          provider: params.provider,
+          messageCount: params.messageCount,
+          routingMode: params.routingMode || void 0,
+          isFirstMessage: params.isFirstMessage
+        });
+        if (API_KEY && result.suggestedModel) {
+          syncEvent(result, params).catch(() => {
+          });
+        }
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+    );
+    productivityEnabled = null;
+    server.tool(
+      "start_session",
+      "Start a productivity tracking session",
+      {
+        task_description: import_zod.z.string().optional(),
+        branch: import_zod.z.string().optional(),
+        repo: import_zod.z.string().optional()
+      },
+      async (params) => {
+        const err = await ensureProductivity();
+        if (err) return { content: [{ type: "text", text: err }] };
+        try {
+          const res = await fetch(`${API_BASE}/v1/productivity/sessions`, {
+            method: "POST",
+            headers: { "Authorization": `Bearer ${API_KEY}`, "Content-Type": "application/json" },
+            body: JSON.stringify(params),
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok) return { content: [{ type: "text", text: `Error: ${res.status} \u2014 ${await res.text()}` }] };
+          const data = await res.json();
+          if (data.data?.id) startHeartbeat(data.data.id);
+          return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+        }
+      }
+    );
+    server.tool(
+      "end_session",
+      "End a productivity tracking session",
+      {
+        session_id: import_zod.z.string(),
+        outcome: import_zod.z.enum(["completed", "abandoned", "paused"]).optional(),
+        artifacts: import_zod.z.array(import_zod.z.string()).optional()
+      },
+      async (params) => {
+        const err = await ensureProductivity();
+        if (err) return { content: [{ type: "text", text: err }] };
+        try {
+          const res = await fetch(`${API_BASE}/v1/productivity/sessions/${params.session_id}`, {
+            method: "PATCH",
+            headers: { "Authorization": `Bearer ${API_KEY}`, "Content-Type": "application/json" },
+            body: JSON.stringify({ outcome: params.outcome, artifacts: params.artifacts }),
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok) return { content: [{ type: "text", text: `Error: ${res.status} \u2014 ${await res.text()}` }] };
+          const data = await res.json();
+          stopHeartbeat();
+          activeSessionId = null;
+          return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+        }
+      }
+    );
+    server.tool(
+      "log_event",
+      "Log a productivity event within a session",
+      {
+        session_id: import_zod.z.string(),
+        event_type: import_zod.z.enum(["prompt", "commit", "pr_created", "test_run", "deploy", "file_edit"]),
+        metadata: import_zod.z.record(import_zod.z.any()).optional()
+      },
+      async (params) => {
+        if (!API_KEY) return { content: [{ type: "text", text: "Not connected to CostLens. Run: npx @costlens/mcp-server setup" }] };
+        if (productivityEnabled === null) {
+          productivityEnabled = await checkFeature("productivity_basic");
+        }
+        const hasFull = await checkFeature("productivity_full");
+        if (!hasFull) return { content: [{ type: "text", text: "Event logging requires Productivity Insights add-on." }] };
+        try {
+          const res = await fetch(`${API_BASE}/v1/productivity/events`, {
+            method: "POST",
+            headers: { "Authorization": `Bearer ${API_KEY}`, "Content-Type": "application/json" },
+            body: JSON.stringify(params),
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok) return { content: [{ type: "text", text: `Error: ${res.status} \u2014 ${await res.text()}` }] };
+          return { content: [{ type: "text", text: "Event logged." }] };
+        } catch (e) {
+          return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+        }
+      }
+    );
+    server.tool(
+      "get_productivity_summary",
+      "Get productivity summary for a time period",
+      {
+        period: import_zod.z.enum(["today", "week", "month"]).optional()
+      },
+      async (params) => {
+        const err = await ensureProductivity();
+        if (err) return { content: [{ type: "text", text: err }] };
+        try {
+          const period = params.period || "week";
+          const res = await fetch(`${API_BASE}/v1/productivity/summary?period=${period}`, {
+            headers: { "Authorization": `Bearer ${API_KEY}` },
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok) return { content: [{ type: "text", text: `Error: ${res.status} \u2014 ${await res.text()}` }] };
+          const data = await res.json();
+          const lines = [
+            `\u{1F4CA} Productivity Summary (${period})`,
+            ``,
+            `Sessions:    ${data.sessions}`,
+            `Time:        ${data.total_time_minutes} min`,
+            `Tokens:      ${data.tokens_used?.toLocaleString() || 0}`,
+            `Cost:        $${data.cost?.toFixed(4) || "0.00"}`,
+            `Commits:     ${data.commits || 0}`,
+            `PRs merged:  ${data.prs_merged || 0}`
+          ];
+          if (data.cost_per_commit) lines.push(`Cost/commit: $${data.cost_per_commit.toFixed(4)}`);
+          if (data.cost_per_pr) lines.push(`Cost/PR:     $${data.cost_per_pr.toFixed(4)}`);
+          if (data.estimated_time_saved_hours) lines.push(`Time saved:  ~${data.estimated_time_saved_hours.toFixed(1)}h`);
+          return { content: [{ type: "text", text: lines.join("\n") }] };
+        } catch (e) {
+          return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+        }
+      }
+    );
+    server.tool(
+      "get_github_metrics",
+      "Get GitHub PR metrics \u2014 PRs merged, review rounds, first-pass rate, cost per PR",
+      {
+        period: import_zod.z.enum(["today", "week", "month"]).optional()
+      },
+      async (params) => {
+        if (!API_KEY) {
+          return { content: [{ type: "text", text: "Not connected to CostLens. Run: npx @costlens/mcp-server setup" }] };
+        }
+        try {
+          const period = params.period || "week";
+          const res = await fetch(`${API_BASE}/v1/productivity/github?period=${period}`, {
+            headers: { "Authorization": `Bearer ${API_KEY}` },
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (res.status === 404) {
+            return { content: [{ type: "text", text: "GitHub not connected. Connect in Settings \u2192 GitHub at costlens.dev" }] };
+          }
+          if (!res.ok) {
+            return { content: [{ type: "text", text: `Error: ${res.status} \u2014 ${await res.text()}` }] };
+          }
+          const { data } = await res.json();
+          const lines = [
+            `GitHub Metrics (${period}):`,
+            `PRs merged:        ${data.prsMerged}`,
+            `Avg review rounds: ${data.avgReviewRounds}`,
+            `First-pass rate:   ${data.firstPassRate}%`,
+            `Avg time to merge: ${data.avgTimeToMergeHours}h`,
+            `Cost per PR:       $${data.costPerPr}`
+          ];
+          return { content: [{ type: "text", text: lines.join("\n") }] };
+        } catch (e) {
+          return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+        }
+      }
+    );
+    main().catch(console.error);
+  }
+});
 
 // src/cli.ts
 var import_http = require("http");
 var import_child_process = require("child_process");
-var import_fs = require("fs");
-var import_os = require("os");
-var import_path = require("path");
-var CONFIG_DIR = (0, import_path.join)((0, import_os.homedir)(), ".costlens");
-var CONFIG_FILE = (0, import_path.join)(CONFIG_DIR, "config.json");
-var API_BASE = process.env.COSTLENS_API_URL || "https://api.costlens.dev";
+var import_fs2 = require("fs");
+var import_os2 = require("os");
+var import_path2 = require("path");
+var CONFIG_DIR = (0, import_path2.join)((0, import_os2.homedir)(), ".costlens");
+var CONFIG_FILE = (0, import_path2.join)(CONFIG_DIR, "config.json");
+var API_BASE2 = process.env.COSTLENS_API_URL || "https://api.costlens.dev";
 var APP_URL = process.env.COSTLENS_APP_URL || "https://costlens.dev";
 function readConfig() {
   try {
-    return JSON.parse((0, import_fs.readFileSync)(CONFIG_FILE, "utf-8"));
+    return JSON.parse((0, import_fs2.readFileSync)(CONFIG_FILE, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeConfig(config) {
-  if (!(0, import_fs.existsSync)(CONFIG_DIR)) (0, import_fs.mkdirSync)(CONFIG_DIR, { recursive: true });
-  (0, import_fs.writeFileSync)(CONFIG_FILE, JSON.stringify(config, null, 2));
+  if (!(0, import_fs2.existsSync)(CONFIG_DIR)) (0, import_fs2.mkdirSync)(CONFIG_DIR, { recursive: true });
+  (0, import_fs2.writeFileSync)(CONFIG_FILE, JSON.stringify(config, null, 2));
 }
 async function login() {
   console.log("\u{1F511} CostLens \u2014 Authenticating...\n");
   const port = 9876 + Math.floor(Math.random() * 100);
-  const server = (0, import_http.createServer)((req, res) => {
+  const server2 = (0, import_http.createServer)((req, res) => {
     const url = new URL(req.url, `http://localhost:${port}`);
     const key = url.searchParams.get("key");
     if (key) {
@@ -36,7 +412,7 @@ async function login() {
       console.log(`  Key saved to ${CONFIG_FILE}
 `);
       setTimeout(() => {
-        server.close();
+        server2.close();
         if (process.argv[2] === "setup") {
           init();
         } else {
@@ -48,7 +424,7 @@ async function login() {
       res.end("Missing key");
     }
   });
-  server.listen(port, () => {
+  server2.listen(port, () => {
     const authUrl = `${APP_URL}/cli-auth?port=${port}`;
     console.log(`  Opening browser: ${authUrl}
 `);
@@ -65,7 +441,7 @@ async function login() {
   });
   setTimeout(() => {
     console.log("\n\u2717 Timed out. Try again.");
-    server.close();
+    server2.close();
     process.exit(1);
   }, 12e4);
 }
@@ -94,21 +470,21 @@ function init() {
   console.log("  Claude Code: ~/.claude/mcp_servers.json");
   console.log("  VS Code:    .vscode/mcp.json");
   console.log("");
-  const kiroPath = (0, import_path.join)((0, import_os.homedir)(), ".kiro", "settings", "mcp.json");
-  const cursorPath = (0, import_path.join)((0, import_os.homedir)(), ".cursor", "mcp.json");
-  const claudePath = (0, import_path.join)((0, import_os.homedir)(), ".claude", "mcp_servers.json");
+  const kiroPath = (0, import_path2.join)((0, import_os2.homedir)(), ".kiro", "settings", "mcp.json");
+  const cursorPath = (0, import_path2.join)((0, import_os2.homedir)(), ".cursor", "mcp.json");
+  const claudePath = (0, import_path2.join)((0, import_os2.homedir)(), ".claude", "mcp_servers.json");
   const paths = [
     { name: "Kiro", path: kiroPath },
     { name: "Cursor", path: cursorPath },
     { name: "Claude Code", path: claudePath }
   ];
   for (const { name, path } of paths) {
-    if ((0, import_fs.existsSync)(path)) {
+    if ((0, import_fs2.existsSync)(path)) {
       try {
-        const existing = JSON.parse((0, import_fs.readFileSync)(path, "utf-8"));
+        const existing = JSON.parse((0, import_fs2.readFileSync)(path, "utf-8"));
         if (!existing.mcpServers?.costlens) {
           existing.mcpServers = { ...existing.mcpServers, ...mcpConfig.mcpServers };
-          (0, import_fs.writeFileSync)(path, JSON.stringify(existing, null, 2));
+          (0, import_fs2.writeFileSync)(path, JSON.stringify(existing, null, 2));
           console.log(`  \u2713 Auto-configured ${name} (${path})`);
         } else {
           console.log(`  \xB7 ${name} already configured`);
@@ -137,7 +513,7 @@ async function status() {
   }
   console.log("\u{1F4CA} CostLens Status\n");
   try {
-    const res = await fetch(`${API_BASE}/v1/spend`, {
+    const res = await fetch(`${API_BASE2}/v1/spend`, {
       headers: { Authorization: `Bearer ${config.apiKey}` },
       signal: AbortSignal.timeout(5e3)
     });
@@ -161,10 +537,8 @@ if (command === "login") login();
 else if (command === "init") init();
 else if (command === "status") status();
 else if (command === "setup") setup();
-else if (command) {
-  console.log(`Unknown command: ${command}`);
-  console.log("Available: setup, login, init, status");
-  process.exit(1);
+else {
+  init_index();
 }
 async function setup() {
   console.log("\u{1F527} CostLens \u2014 One-step setup\n");

package/package.json

@@ -1,13 +1,10 @@
 {
   "name": "@costlens/mcp-server",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "MCP server for AI cost optimization with prompt complexity classification",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "bin": {
-    "costlens-mcp": "./dist/index.js",
-    "costlens": "./dist/cli.js"
-  },
+  "bin": "./dist/cli.js",
   "scripts": {
     "build": "tsup src/index.ts src/cli.ts --format cjs --clean",
     "test": "echo 'no tests yet'"