pricing.md 1.0.0

package/dist/src/tools/find-cheapest.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCheapestSchema = void 0;
+exports.handleFindCheapest = handleFindCheapest;
+const zod_1 = require("zod");
+const pricing_js_1 = require("../schema/pricing.js");
+exports.findCheapestSchema = zod_1.z.object({
+    category: pricing_js_1.CategoryEnum.describe("Tool category to search within"),
+    usage: zod_1.z.record(zod_1.z.string().max(100), zod_1.z.number().nonnegative().max(999_999_999_999)).describe("Usage quantities by metric name, e.g. {emails: 75000}"),
+    seats: zod_1.z.number().int().min(1).max(10_000).optional().describe("Number of team seats (default 1)"),
+});
+function handleFindCheapest(registry, params) {
+    const tools = registry.search({ category: params.category });
+    if (tools.length === 0) {
+        return { error: `No tools found in category "${params.category}".` };
+    }
+    const ranked = [];
+    for (const tool of tools) {
+        const estimates = registry.estimateCost({
+            toolId: tool.id,
+            usage: params.usage,
+            seats: params.seats,
+        });
+        // Pick the cheapest viable tier per tool
+        const viable = estimates.filter((e) => !e.exceedsLimits);
+        const best = viable.length > 0
+            ? viable.reduce((min, e) => e.totalMonthly < min.totalMonthly ? e : min)
+            : null;
+        if (best) {
+            ranked.push({
+                toolId: best.toolId,
+                toolName: best.toolName,
+                tierName: best.tierName,
+                tierSlug: best.tierSlug,
+                currency: best.currency,
+                totalMonthly: best.totalMonthly,
+                seatCost: best.seatCost,
+                basePrice: best.basePrice,
+                usageCosts: best.usageCosts,
+                portability: {
+                    switchingCost: tool.portability.switchingCost,
+                    openStandard: tool.portability.openStandard,
+                },
+                exceedsLimits: false,
+                limitWarnings: [],
+            });
+        }
+        else if (estimates.length > 0) {
+            // All tiers exceed limits — show the least-bad option
+            const leastBad = estimates.reduce((min, e) => e.totalMonthly < min.totalMonthly ? e : min);
+            ranked.push({
+                toolId: leastBad.toolId,
+                toolName: leastBad.toolName,
+                tierName: leastBad.tierName,
+                tierSlug: leastBad.tierSlug,
+                currency: leastBad.currency,
+                totalMonthly: leastBad.totalMonthly,
+                seatCost: leastBad.seatCost,
+                basePrice: leastBad.basePrice,
+                usageCosts: leastBad.usageCosts,
+                portability: {
+                    switchingCost: tool.portability.switchingCost,
+                    openStandard: tool.portability.openStandard,
+                },
+                exceedsLimits: true,
+                limitWarnings: leastBad.limitWarnings,
+            });
+        }
+    }
+    ranked.sort((a, b) => a.totalMonthly - b.totalMonthly);
+    const STALE_DAYS = 90;
+    const now = new Date();
+    const staleTools = tools.filter((t) => {
+        const days = Math.floor((now.getTime() - new Date(t.lastVerified).getTime()) / (1000 * 60 * 60 * 24));
+        return days > STALE_DAYS;
+    });
+    const currencies = new Set(tools.map((t) => t.currency));
+    const hasMixedCurrencies = currencies.size > 1;
+    const warnings = [];
+    if (staleTools.length > 0) {
+        warnings.push(`${staleTools.length} tool(s) have pricing data older than 90 days: ${staleTools.map((t) => t.id).join(", ")}`);
+    }
+    if (hasMixedCurrencies) {
+        warnings.push(`Tools use different currencies (${[...currencies].join(", ")}). Cost ranking may be misleading without conversion.`);
+    }
+    return {
+        category: params.category,
+        usage: params.usage,
+        ...(params.seats ? { seats: params.seats } : {}),
+        results: ranked,
+        ...(warnings.length > 0 ? { warnings } : {}),
+    };
+}

package/dist/src/tools/get-pricing.d.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import type { Registry } from "../registry/registry.js";
+export declare const getPricingSchema: z.ZodObject<{
+    toolId: z.ZodString;
+}, z.core.$strip>;
+export declare function handleGetPricing(registry: Registry, params: z.infer<typeof getPricingSchema>): {
+    error: string;
+} | {
+    warning?: string | undefined;
+    id: string;
+    name: string;
+    description: string;
+    url: string;
+    pricingUrl: string;
+    category: "hosting" | "database" | "auth" | "email" | "payments" | "monitoring" | "ai-api" | "storage" | "ci-cd" | "search" | "analytics" | "feature-flags" | "cms" | "queues" | "edge" | "testing" | "scheduling" | "notifications";
+    tags: string[];
+    tiers: {
+        name: string;
+        slug: string;
+        pricingModel: "free" | "flat_rate" | "per_seat" | "usage_based" | "tiered" | "hybrid" | "custom";
+        basePrice: number | null;
+        billingPeriod: "monthly" | "annual" | null;
+        annualDiscount: number | null;
+        seatPrice: number | null;
+        usageMetrics: {
+            name: string;
+            unit: string;
+            pricePerUnit: number;
+            unitQuantity: number;
+            includedQuantity: number;
+            tieredPricing?: {
+                upTo: number | null;
+                pricePerUnit: number;
+            }[] | undefined;
+        }[];
+        features: {
+            name: string;
+            included: boolean;
+        }[];
+        limits: Record<string, number>;
+    }[];
+    lastVerified: string;
+    freshnessCategory: "stable" | "volatile";
+    currency: string;
+    portability: {
+        switchingCost: "drop-in" | "moderate" | "significant" | "architectural";
+        openStandard: string | null;
+        whatYouLose: string;
+    };
+    error?: undefined;
+};

package/dist/src/tools/get-pricing.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPricingSchema = void 0;
+exports.handleGetPricing = handleGetPricing;
+const zod_1 = require("zod");
+exports.getPricingSchema = zod_1.z.object({
+    toolId: zod_1.z.string().max(100).regex(/^[a-z0-9][a-z0-9-]*$/).describe("The tool ID (slug) to get full pricing for"),
+});
+function handleGetPricing(registry, params) {
+    const tool = registry.get(params.toolId);
+    if (!tool) {
+        return { error: "Tool not found. Use search_tools to find available tools." };
+    }
+    const STALE_DAYS = 90;
+    const now = new Date();
+    const lastVerified = new Date(tool.lastVerified);
+    const daysSinceVerified = Math.floor((now.getTime() - lastVerified.getTime()) / (1000 * 60 * 60 * 24));
+    const isStale = daysSinceVerified > STALE_DAYS;
+    return {
+        ...tool,
+        ...(isStale ? { warning: `Pricing last verified ${daysSinceVerified} days ago — confirm at ${tool.pricingUrl}` } : {}),
+    };
+}

package/dist/src/tools/search-tools.d.ts

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import type { Registry } from "../registry/registry.js";
+export declare const searchToolsSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodEnum<{
+        hosting: "hosting";
+        database: "database";
+        auth: "auth";
+        email: "email";
+        payments: "payments";
+        monitoring: "monitoring";
+        "ai-api": "ai-api";
+        storage: "storage";
+        "ci-cd": "ci-cd";
+        search: "search";
+        analytics: "analytics";
+        "feature-flags": "feature-flags";
+        cms: "cms";
+        queues: "queues";
+        edge: "edge";
+        testing: "testing";
+        scheduling: "scheduling";
+        notifications: "notifications";
+    }>>;
+    hasFreeOption: z.ZodOptional<z.ZodBoolean>;
+    maxBasePrice: z.ZodOptional<z.ZodNumber>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function handleSearchTools(registry: Registry, params: z.infer<typeof searchToolsSchema>): {
+    truncated?: boolean | undefined;
+    showing?: number | undefined;
+    tools: {
+        warning?: string | undefined;
+        id: string;
+        name: string;
+        description: string;
+        category: "hosting" | "database" | "auth" | "email" | "payments" | "monitoring" | "ai-api" | "storage" | "ci-cd" | "search" | "analytics" | "feature-flags" | "cms" | "queues" | "edge" | "testing" | "scheduling" | "notifications";
+        url: string;
+        currency: string;
+        freeTier: {
+            name: string;
+            keyLimits: Record<string, number>;
+        } | null;
+        lowestPaidPrice: number | null;
+        lowestPaidTierName: string;
+        portability: {
+            switchingCost: "drop-in" | "moderate" | "significant" | "architectural";
+            openStandard: string | null;
+            whatYouLose: string;
+        };
+        lastVerified: string;
+    }[];
+    total: number;
+};

package/dist/src/tools/search-tools.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchToolsSchema = void 0;
+exports.handleSearchTools = handleSearchTools;
+const zod_1 = require("zod");
+const pricing_js_1 = require("../schema/pricing.js");
+const MAX_RESULTS = 25;
+exports.searchToolsSchema = zod_1.z.object({
+    query: zod_1.z.string().max(200).optional().describe("Text search across tool names, descriptions, tags, and categories"),
+    category: pricing_js_1.CategoryEnum.optional().describe("Filter by category"),
+    hasFreeOption: zod_1.z.boolean().optional().describe("Only show tools with a free tier"),
+    maxBasePrice: zod_1.z.number().nonnegative().max(999_999_999).optional().describe("Maximum base price for any tier"),
+    tags: zod_1.z.array(zod_1.z.string().max(50)).max(10).optional().describe("Filter by tags"),
+    limit: zod_1.z.number().int().min(1).max(50).optional().describe("Max results to return (default 25)"),
+});
+function handleSearchTools(registry, params) {
+    const limit = params.limit ?? MAX_RESULTS;
+    const allResults = registry.search(params);
+    const results = allResults.slice(0, limit);
+    const STALE_DAYS = 90;
+    const now = new Date();
+    const tools = results.map((tool) => {
+        const lastVerified = new Date(tool.lastVerified);
+        const daysSinceVerified = Math.floor((now.getTime() - lastVerified.getTime()) / (1000 * 60 * 60 * 24));
+        const isStale = daysSinceVerified > STALE_DAYS;
+        const freeTier = tool.tiers.find((t) => t.pricingModel === "free" || t.basePrice === 0);
+        const lowestPaidTier = tool.tiers
+            .filter((t) => t.basePrice !== null && t.basePrice > 0)
+            .sort((a, b) => (a.basePrice ?? 0) - (b.basePrice ?? 0))[0];
+        return {
+            id: tool.id,
+            name: tool.name,
+            description: tool.description,
+            category: tool.category,
+            url: tool.url,
+            currency: tool.currency,
+            freeTier: freeTier
+                ? { name: freeTier.name, keyLimits: freeTier.limits }
+                : null,
+            lowestPaidPrice: lowestPaidTier?.basePrice ?? null,
+            lowestPaidTierName: lowestPaidTier?.name ?? null,
+            portability: tool.portability,
+            lastVerified: tool.lastVerified,
+            ...(isStale ? { warning: `Pricing last verified ${daysSinceVerified} days ago — confirm at ${tool.pricingUrl}` } : {}),
+        };
+    });
+    return {
+        tools,
+        total: allResults.length,
+        ...(allResults.length > limit ? { truncated: true, showing: limit } : {}),
+    };
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "pricing.md",
+  "version": "1.0.0",
+  "description": "Pricing registry for developer tools, exposed as an MCP server",
+  "main": "dist/src/index.js",
+  "bin": {
+    "pricing.md": "dist/src/index.js"
+  },
+  "files": [
+    "dist/src/",
+    "data/tools/",
+    "SKILL.md"
+  ],
+  "scripts": {
+    "discover": "tsx scripts/discover.ts",
+    "parse": "tsx scripts/parse.ts",
+    "validate": "tsx scripts/validate.ts",
+    "build": "tsc",
+    "start": "node dist/src/index.js",
+    "check-freshness": "tsx scripts/check-freshness.ts",
+    "test": "tsx scripts/test-server.ts",
+    "sanity-check": "tsx scripts/sanity-check.ts",
+    "pre-push": "tsx scripts/pre-push.ts"
+  },
+  "keywords": ["mcp", "pricing", "developer-tools", "claude-code"],
+  "author": "Roger Byrne",
+  "license": "MIT",
+  "type": "commonjs",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.5.0",
+    "better-sqlite3": "^12.8.0",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.2"
+  }
+}