@prajwolkc/stk 0.7.0 → 0.8.0

package/dist/mcp/server.js

@@ -8,1803 +8,22 @@
  */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-import { loadConfig, enabledServices } from "../lib/config.js";
-import { getChecker, allCheckerNames, loadPluginCheckers } from "../services/registry.js";
-import { getLocalBrainClient, ingestProject, loadBrainStore, saveBrainStore, syncBrain, pushToCloud, pullFromCloud, brainCheck, brainDiagnose, reviewDiff } from "../services/brain.js";
-import { recordMetric, getMetrics, compareToBaseline, getDeployFrequency, getErrorRate, getUptime } from "../services/metrics.js";
-import { runAllChecks } from "../services/security.js";
-import { execSync } from "child_process";
+import { registerInfraTools } from "./tools/infra.js";
+import { registerOpsTools } from "./tools/ops.js";
+import { registerDataTools } from "./tools/data.js";
+import { registerBrainTools } from "./tools/brain.js";
+import { registerGithubTools } from "./tools/github.js";
+import { registerSecurityTools } from "./tools/security.js";
 const server = new McpServer({
     name: "stk",
-    version: "0.2.0",
-});
-// ──────────────────────────────────────────
-// Tool: stk_health
-// ──────────────────────────────────────────
-server.tool("stk_health", "Check the health of all configured infrastructure services (databases, deploy providers, storage, billing). Returns structured results with status, latency, and details for each service.", {
-    all: z.boolean().optional().describe("Check all known services, not just configured ones"),
-}, async ({ all }) => {
-    await loadPluginCheckers();
-    const config = loadConfig();
-    const serviceList = all ? allCheckerNames() : enabledServices(config);
-    const checks = serviceList.map(async (name) => {
-        const checker = getChecker(name);
-        if (!checker) {
-            return { name, status: "skipped", detail: `unknown service "${name}"` };
-        }
-        return checker();
-    });
-    const results = await Promise.all(checks);
-    const down = results.filter((r) => r.status === "down");
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify({
-                    project: config.name,
-                    services: results,
-                    summary: {
-                        healthy: results.filter((r) => r.status === "healthy").length,
-                        down: down.length,
-                        skipped: results.filter((r) => r.status === "skipped").length,
-                        total: results.length,
-                    },
-                    ok: down.length === 0,
-                }, null, 2),
-            },
-        ],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_status
-// ──────────────────────────────────────────
-server.tool("stk_status", "Get a complete status overview: git state, service health, last deploy, and open issues — everything in one call.", {}, async () => {
-    const config = loadConfig();
-    const status = { project: config.name };
-    // Git
-    try {
-        status.git = {
-            branch: execSync("git rev-parse --abbrev-ref HEAD", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim(),
-            dirty: execSync("git status --porcelain", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim().split("\n").filter(Boolean).length,
-            lastCommit: execSync('git log -1 --format="%s"', { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim(),
-            lastCommitAge: execSync('git log -1 --format="%cr"', { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim(),
-        };
-    }
-    catch {
-        status.git = null;
-    }
-    // Services
-    await loadPluginCheckers();
-    const serviceList = enabledServices(config);
-    if (serviceList.length > 0) {
-        const checks = serviceList.map(async (name) => {
-            const checker = getChecker(name);
-            if (!checker)
-                return { name, status: "skipped" };
-            return checker();
-        });
-        const results = await Promise.all(checks);
-        status.services = {
-            healthy: results.filter((r) => r.status === "healthy").length,
-            down: results.filter((r) => r.status === "down").map((r) => r.name),
-            skipped: results.filter((r) => r.status === "skipped").length,
-            total: results.length,
-        };
-    }
-    else {
-        status.services = { total: 0, note: "no services configured" };
-    }
-    // Deploy
-    if (process.env.VERCEL_TOKEN) {
-        try {
-            const res = await fetch("https://api.vercel.com/v6/deployments?limit=1", {
-                headers: { Authorization: `Bearer ${process.env.VERCEL_TOKEN}` },
-            });
-            const data = (await res.json());
-            const dep = data.deployments?.[0];
-            if (dep) {
-                status.lastDeploy = {
-                    provider: "vercel",
-                    state: dep.readyState ?? dep.state,
-                    url: dep.url,
-                    created: dep.created,
-                };
-            }
-        }
-        catch { /* skip */ }
-    }
-    return {
-        content: [{ type: "text", text: JSON.stringify(status, null, 2) }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_doctor
-// ──────────────────────────────────────────
-server.tool("stk_doctor", "Diagnose infrastructure configuration issues. Checks for missing env vars, mismatched config, invalid URLs, and suggests fixes with documentation links.", {}, async () => {
-    const config = loadConfig();
-    const enabled = enabledServices(config);
-    const issues = [];
-    const ENV_REQS = {
-        railway: { required: ["RAILWAY_API_TOKEN"], optional: ["RAILWAY_PROJECT_ID", "RAILWAY_ENVIRONMENT_ID", "RAILWAY_SERVICE_ID"] },
-        vercel: { required: ["VERCEL_TOKEN"], optional: ["VERCEL_PROJECT_ID"] },
-        fly: { required: ["FLY_API_TOKEN"], optional: ["FLY_APP_NAME"] },
-        render: { required: ["RENDER_API_KEY"], optional: [] },
-        aws: { required: ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"], optional: ["AWS_REGION"] },
-        database: { required: ["DATABASE_URL"], optional: [] },
-        mongodb: { required: ["MONGODB_URL"], optional: [] },
-        redis: { required: ["REDIS_URL"], optional: [] },
-        supabase: { required: ["SUPABASE_URL"], optional: ["SUPABASE_SERVICE_KEY"] },
-        r2: { required: ["CLOUDFLARE_ACCOUNT_ID", "CLOUDFLARE_API_TOKEN"], optional: [] },
-        stripe: { required: ["STRIPE_SECRET_KEY"], optional: [] },
-    };
-    for (const svc of enabled) {
-        const reqs = ENV_REQS[svc];
-        if (!reqs)
-            continue;
-        const missingReq = reqs.required.filter((v) => !process.env[v]);
-        const missingOpt = reqs.optional.filter((v) => !process.env[v]);
-        if (missingReq.length > 0) {
-            issues.push({ level: "error", service: svc, message: `Missing required: ${missingReq.join(", ")}` });
-        }
-        else {
-            issues.push({ level: "ok", service: svc, message: "Configured correctly" });
-        }
-        if (missingOpt.length > 0) {
-            issues.push({ level: "warn", service: svc, message: `Missing optional: ${missingOpt.join(", ")}`, fix: "Needed for logs, env sync, deploy watching" });
-        }
-    }
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    project: config.name,
-                    issues,
-                    summary: {
-                        errors: issues.filter((i) => i.level === "error").length,
-                        warnings: issues.filter((i) => i.level === "warn").length,
-                        ok: issues.filter((i) => i.level === "ok").length,
-                    },
-                }, null, 2),
-            }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_logs
-// ──────────────────────────────────────────
-server.tool("stk_logs", "Fetch recent production logs from Railway, Vercel, or other deploy providers. Useful for diagnosing errors and understanding runtime behavior.", {
-    provider: z.enum(["railway", "vercel"]).optional().describe("Which provider to fetch logs from (auto-detects if omitted)"),
-    lines: z.number().optional().default(30).describe("Number of log lines to fetch"),
-}, async ({ provider, lines }) => {
-    // Railway logs
-    if ((provider === "railway" || !provider) && process.env.RAILWAY_API_TOKEN) {
-        const token = process.env.RAILWAY_API_TOKEN;
-        const projectId = process.env.RAILWAY_PROJECT_ID;
-        const serviceId = process.env.RAILWAY_SERVICE_ID;
-        if (!projectId) {
-            return { content: [{ type: "text", text: JSON.stringify({ error: "RAILWAY_PROJECT_ID not set" }) }] };
-        }
-        // Get latest deployment
-        const serviceFilter = serviceId ? `serviceId: "${serviceId}",` : "";
-        const depRes = await fetch("https://backboard.railway.com/graphql/v2", {
-            method: "POST",
-            headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
-            body: JSON.stringify({
-                query: `{ deployments(first: 1, input: { projectId: "${projectId}", ${serviceFilter} }) { edges { node { id } } } }`,
-            }),
-        });
-        const depData = (await depRes.json());
-        const deploymentId = depData.data?.deployments?.edges?.[0]?.node?.id;
-        if (!deploymentId) {
-            return { content: [{ type: "text", text: JSON.stringify({ error: "No deployments found" }) }] };
-        }
-        const logRes = await fetch("https://backboard.railway.com/graphql/v2", {
-            method: "POST",
-            headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
-            body: JSON.stringify({
-                query: `{ deploymentLogs(deploymentId: "${deploymentId}", limit: ${lines}) { timestamp message severity } }`,
-            }),
-        });
-        const logData = (await logRes.json());
-        const logs = logData.data?.deploymentLogs ?? [];
-        return {
-            content: [{ type: "text", text: JSON.stringify({ provider: "railway", deploymentId, logs }, null, 2) }],
-        };
-    }
-    // Vercel logs
-    if ((provider === "vercel" || !provider) && process.env.VERCEL_TOKEN) {
-        const token = process.env.VERCEL_TOKEN;
-        const depRes = await fetch("https://api.vercel.com/v6/deployments?limit=1", {
-            headers: { Authorization: `Bearer ${token}` },
-        });
-        const depData = (await depRes.json());
-        const dep = depData.deployments?.[0];
-        if (!dep) {
-            return { content: [{ type: "text", text: JSON.stringify({ error: "No deployments found" }) }] };
-        }
-        const logRes = await fetch(`https://api.vercel.com/v2/deployments/${dep.uid}/events`, {
-            headers: { Authorization: `Bearer ${token}` },
-        });
-        const events = (await logRes.json());
-        const logs = Array.isArray(events)
-            ? events
-                .filter((e) => e.type === "stdout" || e.type === "stderr")
-                .slice(-lines)
-                .map((e) => ({
-                timestamp: new Date(e.created).toISOString(),
-                message: e.payload?.text ?? e.text ?? "",
-                severity: e.type === "stderr" ? "ERROR" : "INFO",
-            }))
-            : [];
-        return {
-            content: [{ type: "text", text: JSON.stringify({ provider: "vercel", deploymentUrl: dep.url, logs }, null, 2) }],
-        };
-    }
-    return {
-        content: [{ type: "text", text: JSON.stringify({ error: "No log provider available. Set RAILWAY_API_TOKEN or VERCEL_TOKEN." }) }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_todo_list
-// ──────────────────────────────────────────
-server.tool("stk_todo_list", "List open GitHub issues for this project. Helps understand what needs to be worked on.", {
-    label: z.string().optional().describe("Filter by label"),
-    limit: z.number().optional().default(15).describe("Max issues to return"),
-}, async ({ label, limit }) => {
-    const config = loadConfig();
-    const repo = config.github?.repo ?? process.env.GITHUB_REPO ?? detectGitHubRepo();
-    const token = process.env.GITHUB_TOKEN;
-    if (!repo) {
-        return { content: [{ type: "text", text: JSON.stringify({ error: "Could not detect GitHub repo. Set GITHUB_REPO or add github.repo to stk.config.json" }) }] };
-    }
-    const params = new URLSearchParams({
-        state: "open",
-        per_page: String(limit),
-        sort: "updated",
-        direction: "desc",
-    });
-    if (label)
-        params.set("labels", label);
-    const headers = { Accept: "application/vnd.github+json" };
-    if (token)
-        headers.Authorization = `Bearer ${token}`;
-    const res = await fetch(`https://api.github.com/repos/${repo}/issues?${params}`, { headers });
-    if (!res.ok) {
-        return { content: [{ type: "text", text: JSON.stringify({ error: `GitHub API: ${res.status}` }) }] };
-    }
-    const issues = (await res.json());
-    const filtered = issues
-        .filter((i) => !i.pull_request)
-        .map((i) => ({
-        number: i.number,
-        title: i.title,
-        labels: i.labels.map((l) => l.name),
-        assignee: i.assignee?.login ?? null,
-        created: i.created_at,
-        url: i.html_url,
-    }));
-    return {
-        content: [{ type: "text", text: JSON.stringify({ repo, issues: filtered }, null, 2) }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_todo_add
-// ──────────────────────────────────────────
-server.tool("stk_todo_add", "Create a new GitHub issue for this project.", {
-    title: z.string().describe("Issue title"),
-    body: z.string().optional().describe("Issue body/description"),
-    labels: z.array(z.string()).optional().describe("Labels to add"),
-}, async ({ title, body, labels }) => {
-    const config = loadConfig();
-    const repo = config.github?.repo ?? process.env.GITHUB_REPO ?? detectGitHubRepo();
-    const token = process.env.GITHUB_TOKEN;
-    if (!repo || !token) {
-        return { content: [{ type: "text", text: JSON.stringify({ error: "Need GITHUB_TOKEN and repo to create issues" }) }] };
-    }
-    const payload = { title };
-    if (body)
-        payload.body = body;
-    if (labels)
-        payload.labels = labels;
-    const res = await fetch(`https://api.github.com/repos/${repo}/issues`, {
-        method: "POST",
-        headers: {
-            Authorization: `Bearer ${token}`,
-            Accept: "application/vnd.github+json",
-            "Content-Type": "application/json",
-        },
-        body: JSON.stringify(payload),
-    });
-    if (!res.ok) {
-        const data = (await res.json());
-        return { content: [{ type: "text", text: JSON.stringify({ error: data.message ?? `HTTP ${res.status}` }) }] };
-    }
-    const issue = (await res.json());
-    return {
-        content: [{ type: "text", text: JSON.stringify({ created: true, number: issue.number, url: issue.html_url }, null, 2) }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_deploy
-// ──────────────────────────────────────────
-server.tool("stk_deploy", "Push current branch to remote and trigger deploys. Use with caution — this pushes code to production.", {
-    skipPush: z.boolean().optional().describe("Skip git push, just report current deploy status"),
-}, async ({ skipPush }) => {
-    const config = loadConfig();
-    const branch = config.deploy?.branch ?? "main";
-    if (!skipPush) {
-        try {
-            const currentBranch = execSync("git rev-parse --abbrev-ref HEAD", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-            if (currentBranch !== branch) {
-                return {
-                    content: [{ type: "text", text: JSON.stringify({ error: `On branch "${currentBranch}", not "${branch}". Switch branches first.` }) }],
-                };
-            }
-            execSync(`git push origin ${branch}`, { encoding: "utf-8", stdio: "pipe" });
-        }
-        catch (err) {
-            return {
-                content: [{ type: "text", text: JSON.stringify({ error: `Git push failed: ${err.message}` }) }],
-            };
-        }
-    }
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    pushed: !skipPush,
-                    branch,
-                    providers: config.deploy?.providers ?? [],
-                    note: "Deploy triggered. Use stk_health to verify after a few minutes.",
-                }, null, 2),
-            }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_config
-// ──────────────────────────────────────────
-server.tool("stk_config", "Read the current stk configuration for this project. Shows which services are enabled, deploy settings, and project name.", {}, async () => {
-    const config = loadConfig();
-    return {
-        content: [{ type: "text", text: JSON.stringify(config, null, 2) }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_db
-// ──────────────────────────────────────────
-server.tool("stk_db", "Query your Supabase database directly. Run SELECT queries, check row counts, inspect table data — all from chat. Only read operations are allowed for safety.", {
-    query: z.string().optional().describe("SQL query to run (SELECT only for safety)"),
-    table: z.string().optional().describe("Shorthand: just provide a table name to SELECT * with a limit"),
-    limit: z.number().optional().describe("Max rows to return (default 20)"),
-}, async ({ query, table, limit: rawLimit }) => {
-    const limit = rawLimit ?? 20;
-    const url = process.env.SUPABASE_URL;
-    const key = process.env.SUPABASE_SERVICE_KEY;
-    if (!url || !key) {
-        return { content: [{ type: "text", text: JSON.stringify({ error: "SUPABASE_URL or SUPABASE_SERVICE_KEY not set" }) }] };
-    }
-    // If table shorthand is used, build a simple query
-    let sql = query ?? "";
-    if (table && !query) {
-        sql = `SELECT * FROM ${table} ORDER BY created_at DESC LIMIT ${limit}`;
-    }
-    if (!sql && !table) {
-        return { content: [{ type: "text", text: JSON.stringify({ error: "Provide either a 'query' or 'table' parameter" }) }] };
-    }
-    // Safety: only allow read operations
-    const normalized = sql.trim().toUpperCase();
-    if (!normalized.startsWith("SELECT") && !normalized.startsWith("WITH")) {
-        return { content: [{ type: "text", text: JSON.stringify({ error: "Only SELECT/WITH queries are allowed for safety. Use Supabase dashboard for mutations." }) }] };
-    }
-    try {
-        const res = await fetch(`${url}/rest/v1/rpc/`, {
-            method: "POST",
-            headers: {
-                apikey: key,
-                Authorization: `Bearer ${key}`,
-                "Content-Type": "application/json",
-                Prefer: "return=representation",
-            },
-            body: JSON.stringify({}),
-        });
-        // Use PostgREST query instead of RPC for better compatibility
-        // Parse table name from SQL for simple queries
-        const tableMatch = sql.match(/FROM\s+["']?(\w+)["']?/i);
-        const targetTable = table ?? tableMatch?.[1];
-        if (targetTable) {
-            const restRes = await fetch(`${url}/rest/v1/${targetTable}?select=*&limit=${limit}`, {
-                headers: {
-                    apikey: key,
-                    Authorization: `Bearer ${key}`,
-                    "Content-Type": "application/json",
-                    Prefer: "count=exact",
-                },
-            });
-            if (!restRes.ok) {
-                const errText = await restRes.text();
-                return { content: [{ type: "text", text: JSON.stringify({ error: `Query failed: ${errText}` }) }] };
-            }
-            const contentRange = restRes.headers.get("content-range");
-            const totalCount = contentRange ? contentRange.split("/")[1] : "unknown";
-            const data = await restRes.json();
-            return {
-                content: [{
-                        type: "text",
-                        text: JSON.stringify({
-                            table: targetTable,
-                            totalRows: totalCount,
-                            returned: Array.isArray(data) ? data.length : 0,
-                            data,
-                        }, null, 2),
-                    }],
-            };
-        }
-        return { content: [{ type: "text", text: JSON.stringify({ error: "Could not parse table name from query. Use the 'table' parameter instead." }) }] };
-    }
-    catch (err) {
-        return { content: [{ type: "text", text: JSON.stringify({ error: err.message }) }] };
-    }
-});
-// ──────────────────────────────────────────
-// Tool: stk_analytics
-// ──────────────────────────────────────────
-server.tool("stk_analytics", "Get live app analytics: total users, posts, payments, revenue, and recent activity. Pulls data from Supabase and Stripe in one call.", {}, async () => {
-    const results = {};
-    // Supabase stats
-    const url = process.env.SUPABASE_URL;
-    const key = process.env.SUPABASE_SERVICE_KEY;
-    if (url && key) {
-        const headers = {
-            apikey: key,
-            Authorization: `Bearer ${key}`,
-            Prefer: "count=exact",
-        };
-        // Get table counts in parallel
-        const [postsRes, usersRes, paymentsRes] = await Promise.all([
-            fetch(`${url}/rest/v1/posts?select=id&limit=0`, { headers }).catch(() => null),
-            fetch(`${url}/rest/v1/users?select=id&limit=0`, { headers }).catch(() => null),
-            fetch(`${url}/rest/v1/payments?select=id&limit=0`, { headers }).catch(() => null),
-        ]);
-        const getCount = (res) => {
-            if (!res?.ok)
-                return null;
-            const range = res.headers.get("content-range");
-            return range ? parseInt(range.split("/")[1]) || 0 : null;
-        };
-        results.supabase = {
-            totalPosts: getCount(postsRes),
-            totalUsers: getCount(usersRes),
-            totalPayments: getCount(paymentsRes),
-        };
-        // Recent posts (last 24h)
-        const oneDayAgo = Math.floor(Date.now() / 1000) - 86400;
-        const recentRes = await fetch(`${url}/rest/v1/posts?select=id&timestamp=gte.${oneDayAgo}&limit=0`, { headers: { ...headers, Prefer: "count=exact" } }).catch(() => null);
-        results.supabase.postsLast24h = getCount(recentRes);
-        // Recent users with paid posts
-        const paidUsersRes = await fetch(`${url}/rest/v1/users?select=id&paid_posts_available=gt.0&limit=0`, { headers: { ...headers, Prefer: "count=exact" } }).catch(() => null);
-        results.supabase.usersWithPaidPosts = getCount(paidUsersRes);
-    }
-    // Stripe stats
-    const stripeKey = process.env.STRIPE_SECRET_KEY;
-    if (stripeKey) {
-        try {
-            // Balance
-            const balRes = await fetch("https://api.stripe.com/v1/balance", {
-                headers: { Authorization: `Bearer ${stripeKey}` },
-            });
-            const balData = await balRes.json();
-            // Recent charges
-            const chargesRes = await fetch("https://api.stripe.com/v1/charges?limit=100", {
-                headers: { Authorization: `Bearer ${stripeKey}` },
-            });
-            const chargesData = await chargesRes.json();
-            const charges = chargesData.data ?? [];
-            const totalRevenue = charges.reduce((sum, c) => sum + (c.status === "succeeded" ? c.amount : 0), 0);
-            results.stripe = {
-                balance: balData.available?.map((b) => `${(b.amount / 100).toFixed(2)} ${b.currency.toUpperCase()}`) ?? [],
-                totalCharges: charges.length,
-                successfulCharges: charges.filter((c) => c.status === "succeeded").length,
-                totalRevenue: `${(totalRevenue / 100).toFixed(2)}`,
-                mode: stripeKey.startsWith("sk_live") ? "live" : "test",
-            };
-        }
-        catch (err) {
-            results.stripe = { error: err.message };
-        }
-    }
-    return {
-        content: [{ type: "text", text: JSON.stringify({ analytics: results }, null, 2) }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_alerts
-// ──────────────────────────────────────────
-server.tool("stk_alerts", "Scan for problems across your entire stack: failed deploys, down services, error logs, Stripe failures, and database issues. Returns actionable alerts.", {}, async () => {
-    await loadPluginCheckers();
-    const config = loadConfig();
-    const alerts = [];
-    // 1. Check all service health
-    const serviceList = enabledServices(config);
-    const checks = serviceList.map(async (name) => {
-        const checker = getChecker(name);
-        if (!checker)
-            return null;
-        return checker();
-    });
-    const results = (await Promise.all(checks)).filter(Boolean);
-    for (const r of results) {
-        if (r.status === "down") {
-            alerts.push({ level: "critical", source: r.name, message: `Service is DOWN: ${r.detail ?? "unreachable"}` });
-        }
-        else if (r.status === "degraded") {
-            alerts.push({ level: "warning", source: r.name, message: `Service degraded: ${r.detail ?? "slow response"}` });
-        }
-        else if (r.latency && r.latency > 3000) {
-            alerts.push({ level: "warning", source: r.name, message: `High latency: ${r.latency}ms` });
-        }
-    }
-    // 2. Check Vercel for failed deploys
-    if (process.env.VERCEL_TOKEN) {
-        try {
-            const res = await fetch("https://api.vercel.com/v6/deployments?limit=5", {
-                headers: { Authorization: `Bearer ${process.env.VERCEL_TOKEN}` },
-            });
-            const data = await res.json();
-            for (const dep of data.deployments ?? []) {
-                const state = dep.readyState ?? dep.state;
-                if (state === "ERROR" || state === "CANCELED") {
-                    alerts.push({ level: "critical", source: "Vercel", message: `Deploy ${state}: ${dep.url ?? dep.uid}` });
-                }
-            }
-        }
-        catch { /* skip */ }
-    }
-    // 3. Check Stripe for recent failures
-    if (process.env.STRIPE_SECRET_KEY) {
-        try {
-            const res = await fetch("https://api.stripe.com/v1/charges?limit=20", {
-                headers: { Authorization: `Bearer ${process.env.STRIPE_SECRET_KEY}` },
-            });
-            const data = await res.json();
-            const failed = (data.data ?? []).filter((c) => c.status === "failed");
-            if (failed.length > 0) {
-                alerts.push({ level: "warning", source: "Stripe", message: `${failed.length} failed charge(s) in recent transactions` });
-            }
-        }
-        catch { /* skip */ }
-    }
-    // 4. Check for error logs in Vercel
-    if (process.env.VERCEL_TOKEN) {
-        try {
-            const depRes = await fetch("https://api.vercel.com/v6/deployments?limit=1", {
-                headers: { Authorization: `Bearer ${process.env.VERCEL_TOKEN}` },
-            });
-            const depData = await depRes.json();
-            const dep = depData.deployments?.[0];
-            if (dep) {
-                const logRes = await fetch(`https://api.vercel.com/v2/deployments/${dep.uid}/events`, {
-                    headers: { Authorization: `Bearer ${process.env.VERCEL_TOKEN}` },
-                });
-                const events = await logRes.json();
-                if (Array.isArray(events)) {
-                    const errors = events.filter((e) => e.type === "stderr");
-                    if (errors.length > 5) {
-                        alerts.push({ level: "warning", source: "Vercel Logs", message: `${errors.length} stderr entries in latest deploy` });
-                    }
-                }
-            }
-        }
-        catch { /* skip */ }
-    }
-    if (alerts.length === 0) {
-        alerts.push({ level: "info", source: "stk", message: "All clear — no issues detected" });
-    }
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    project: config.name,
-                    alerts,
-                    summary: {
-                        critical: alerts.filter((a) => a.level === "critical").length,
-                        warnings: alerts.filter((a) => a.level === "warning").length,
-                        ok: alerts.every((a) => a.level === "info"),
-                    },
-                }, null, 2),
-            }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_rollback
-// ──────────────────────────────────────────
-server.tool("stk_rollback", "Rollback to a previous Vercel deployment. Lists recent deploys and can promote an older one to production.", {
-    deployId: z.string().optional().describe("Deployment ID to rollback to. If omitted, lists recent deployments to choose from."),
-    confirm: z.boolean().optional().default(false).describe("Must be true to actually execute the rollback"),
-}, async ({ deployId, confirm }) => {
-    const token = process.env.VERCEL_TOKEN;
-    if (!token) {
-        return { content: [{ type: "text", text: JSON.stringify({ error: "VERCEL_TOKEN not set" }) }] };
-    }
-    // List recent deployments
-    const depRes = await fetch("https://api.vercel.com/v6/deployments?limit=10", {
-        headers: { Authorization: `Bearer ${token}` },
-    });
-    const depData = await depRes.json();
-    const deployments = (depData.deployments ?? []).map((d) => ({
-        id: d.uid,
-        url: d.url,
-        state: d.readyState ?? d.state,
-        created: new Date(d.created).toISOString(),
-        target: d.target ?? "preview",
-    }));
-    if (!deployId) {
-        return {
-            content: [{
-                    type: "text",
-                    text: JSON.stringify({
-                        message: "Recent deployments — provide a deployId to rollback",
-                        deployments,
-                    }, null, 2),
-                }],
-        };
-    }
-    if (!confirm) {
-        const target = deployments.find((d) => d.id === deployId);
-        return {
-            content: [{
-                    type: "text",
-                    text: JSON.stringify({
-                        message: "Rollback requires confirmation. Call again with confirm: true",
-                        target: target ?? deployId,
-                    }, null, 2),
-                }],
-        };
-    }
-    // Execute rollback by promoting the old deployment
-    try {
-        // Get the deployment's project
-        const detailRes = await fetch(`https://api.vercel.com/v13/deployments/${deployId}`, {
-            headers: { Authorization: `Bearer ${token}` },
-        });
-        const detail = await detailRes.json();
-        const projectId = detail.projectId;
-        if (!projectId) {
-            return { content: [{ type: "text", text: JSON.stringify({ error: "Could not determine project from deployment" }) }] };
-        }
-        // Create a new deployment based on the old one (redeploy)
-        const rollbackRes = await fetch(`https://api.vercel.com/v13/deployments`, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${token}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-                name: detail.name,
-                deploymentId: deployId,
-                target: "production",
-            }),
-        });
-        if (!rollbackRes.ok) {
-            const errData = await rollbackRes.json();
-            return { content: [{ type: "text", text: JSON.stringify({ error: errData.error?.message ?? `HTTP ${rollbackRes.status}` }) }] };
-        }
-        const rollbackData = await rollbackRes.json();
-        return {
-            content: [{
-                    type: "text",
-                    text: JSON.stringify({
-                        rolledBack: true,
-                        newDeploymentId: rollbackData.id,
-                        url: rollbackData.url,
-                        note: "Rollback triggered. Use stk_health to verify.",
-                    }, null, 2),
-                }],
-        };
-    }
-    catch (err) {
-        return { content: [{ type: "text", text: JSON.stringify({ error: err.message }) }] };
-    }
-});
-// ──────────────────────────────────────────
-// Tool: stk_env_sync
-// ──────────────────────────────────────────
-server.tool("stk_env_sync", "Compare and sync environment variables between local .env and Vercel. Shows which vars are missing, extra, or mismatched.", {
-    action: z.enum(["diff", "pull", "push"]).optional().default("diff").describe("diff: compare local vs remote. pull: download remote to .env.pulled. push: upload local to Vercel."),
-    confirm: z.boolean().optional().default(false).describe("Required for push action"),
-}, async ({ action, confirm }) => {
-    const token = process.env.VERCEL_TOKEN;
-    const projectId = process.env.VERCEL_PROJECT_ID;
-    // Read local .env
-    let localVars = {};
-    try {
-        const { readFileSync } = await import("fs");
-        const envContent = readFileSync(".env", "utf-8");
-        for (const line of envContent.split("\n")) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith("#"))
-                continue;
-            const eqIdx = trimmed.indexOf("=");
-            if (eqIdx > 0) {
-                localVars[trimmed.slice(0, eqIdx)] = trimmed.slice(eqIdx + 1);
-            }
-        }
-    }
-    catch {
-        localVars = {};
-    }
-    if (!token) {
-        return {
-            content: [{
-                    type: "text",
-                    text: JSON.stringify({
-                        localVars: Object.keys(localVars),
-                        remote: "VERCEL_TOKEN not set — cannot fetch remote env vars",
-                    }, null, 2),
-                }],
-        };
-    }
-    // Fetch Vercel env vars
-    let remoteVars = {};
-    const envUrl = projectId
-        ? `https://api.vercel.com/v9/projects/${projectId}/env`
-        : null;
-    if (envUrl) {
-        try {
-            const res = await fetch(envUrl, {
-                headers: { Authorization: `Bearer ${token}` },
-            });
-            const data = await res.json();
-            for (const env of data.envs ?? []) {
-                remoteVars[env.key] = env.value ?? "(encrypted)";
-            }
-        }
-        catch { /* skip */ }
-    }
-    const localKeys = new Set(Object.keys(localVars));
-    const remoteKeys = new Set(Object.keys(remoteVars));
-    const onlyLocal = [...localKeys].filter((k) => !remoteKeys.has(k));
-    const onlyRemote = [...remoteKeys].filter((k) => !localKeys.has(k));
-    const shared = [...localKeys].filter((k) => remoteKeys.has(k));
-    if (action === "diff" || !action) {
-        return {
-            content: [{
-                    type: "text",
-                    text: JSON.stringify({
-                        localCount: localKeys.size,
-                        remoteCount: remoteKeys.size,
-                        onlyInLocal: onlyLocal,
-                        onlyInRemote: onlyRemote,
-                        inBoth: shared.length,
-                        note: projectId ? undefined : "Set VERCEL_PROJECT_ID for remote env comparison",
-                    }, null, 2),
-                }],
-        };
-    }
-    if (action === "pull") {
-        const { writeFileSync } = await import("fs");
-        const lines = Object.entries(remoteVars).map(([k, v]) => `${k}=${v}`);
-        writeFileSync(".env.pulled", lines.join("\n") + "\n");
-        return {
-            content: [{ type: "text", text: JSON.stringify({ pulled: true, file: ".env.pulled", count: lines.length }) }],
-        };
-    }
-    if (action === "push") {
-        if (!confirm) {
-            return {
-                content: [{ type: "text", text: JSON.stringify({ message: "Push requires confirm: true. This will overwrite remote env vars.", varsToUpload: onlyLocal.length + shared.length }) }],
-            };
-        }
-        if (!projectId || !envUrl) {
-            return { content: [{ type: "text", text: JSON.stringify({ error: "VERCEL_PROJECT_ID required for push" }) }] };
-        }
-        let uploaded = 0;
-        for (const [key, value] of Object.entries(localVars)) {
-            await fetch(envUrl, {
-                method: "POST",
-                headers: {
-                    Authorization: `Bearer ${token}`,
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify({
-                    key,
-                    value,
-                    type: "encrypted",
-                    target: ["production", "preview", "development"],
-                }),
-            });
-            uploaded++;
-        }
-        return {
-            content: [{ type: "text", text: JSON.stringify({ pushed: true, uploaded }) }],
-        };
-    }
-    return { content: [{ type: "text", text: JSON.stringify({ error: "Unknown action" }) }] };
-});
-// ──────────────────────────────────────────
-// Tool: stk_perf
-// ──────────────────────────────────────────
-server.tool("stk_perf", "Check performance across your stack: Supabase query latency, table sizes, Vercel deploy times, and API response times.", {
-    tables: z.array(z.string()).optional().describe("Specific Supabase tables to benchmark (defaults to all detected)"),
-}, async ({ tables }) => {
-    const perf = {};
-    // Supabase performance
-    const url = process.env.SUPABASE_URL;
-    const key = process.env.SUPABASE_SERVICE_KEY;
-    if (url && key) {
-        const headers = {
-            apikey: key,
-            Authorization: `Bearer ${key}`,
-            Prefer: "count=exact",
-        };
-        // Auto-detect tables or use provided list
-        const tablesToCheck = tables ?? ["posts", "users", "payments"];
-        const tableStats = [];
-        for (const table of tablesToCheck) {
-            const start = Date.now();
-            try {
-                const res = await fetch(`${url}/rest/v1/${table}?select=id&limit=0`, {
-                    headers,
-                });
-                const latency = Date.now() - start;
-                const range = res.headers.get("content-range");
-                const count = range ? parseInt(range.split("/")[1]) || 0 : null;
-                let status = "fast";
-                if (latency > 1000)
-                    status = "slow";
-                else if (latency > 500)
-                    status = "moderate";
-                tableStats.push({ table, rowCount: count, queryLatency: latency, status });
-            }
-            catch {
-                tableStats.push({ table, rowCount: null, queryLatency: Date.now() - start, status: "error" });
-            }
-        }
-        // API latency test
-        const apiStart = Date.now();
-        await fetch(`${url}/rest/v1/`, { headers }).catch(() => null);
-        const apiLatency = Date.now() - apiStart;
-        perf.supabase = {
-            apiLatency,
-            tables: tableStats,
-            recommendation: tableStats.some((t) => t.status === "slow")
-                ? "Some queries are slow. Consider adding database indexes."
-                : tableStats.some((t) => (t.rowCount ?? 0) > 10000)
-                    ? "Large tables detected. Ensure you have indexes on frequently queried columns."
-                    : "Performance looks good.",
-        };
-    }
-    // Vercel deploy performance
-    if (process.env.VERCEL_TOKEN) {
-        try {
-            const res = await fetch("https://api.vercel.com/v6/deployments?limit=5", {
-                headers: { Authorization: `Bearer ${process.env.VERCEL_TOKEN}` },
-            });
-            const data = await res.json();
-            const deploys = (data.deployments ?? []).map((d) => {
-                const buildDuration = d.buildingAt && d.ready
-                    ? Math.round((d.ready - d.buildingAt) / 1000)
-                    : null;
-                return {
-                    id: d.uid,
-                    state: d.readyState ?? d.state,
-                    buildDuration: buildDuration ? `${buildDuration}s` : "unknown",
-                    created: new Date(d.created).toISOString(),
-                };
-            });
-            perf.vercel = {
-                recentDeploys: deploys,
-                avgBuildTime: deploys.filter((d) => d.buildDuration !== "unknown").length > 0
-                    ? "see individual deploys"
-                    : "no build data available",
-            };
-        }
-        catch { /* skip */ }
-    }
-    // Stripe API latency
-    if (process.env.STRIPE_SECRET_KEY) {
-        const start = Date.now();
-        await fetch("https://api.stripe.com/v1/balance", {
-            headers: { Authorization: `Bearer ${process.env.STRIPE_SECRET_KEY}` },
-        }).catch(() => null);
-        perf.stripe = { apiLatency: Date.now() - start };
-    }
-    return {
-        content: [{ type: "text", text: JSON.stringify({ performance: perf }, null, 2) }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_cost
-// ──────────────────────────────────────────
-server.tool("stk_cost", "Track costs across your stack: Stripe fees, Vercel usage, Supabase plan details. Get a unified view of what you're spending.", {}, async () => {
-    const costs = {};
-    // Stripe revenue & fees
-    if (process.env.STRIPE_SECRET_KEY) {
-        try {
-            const stripeKey = process.env.STRIPE_SECRET_KEY;
-            // Balance
-            const balRes = await fetch("https://api.stripe.com/v1/balance", {
-                headers: { Authorization: `Bearer ${stripeKey}` },
-            });
-            const balData = await balRes.json();
-            // Recent balance transactions for fee tracking
-            const txRes = await fetch("https://api.stripe.com/v1/balance_transactions?limit=100", {
-                headers: { Authorization: `Bearer ${stripeKey}` },
-            });
-            const txData = await txRes.json();
-            const transactions = txData.data ?? [];
-            const totalFees = transactions.reduce((sum, t) => sum + (t.fee || 0), 0);
-            const totalGross = transactions.reduce((sum, t) => sum + (t.amount > 0 ? t.amount : 0), 0);
-            const totalNet = transactions.reduce((sum, t) => sum + (t.net || 0), 0);
-            costs.stripe = {
-                mode: stripeKey.startsWith("sk_live") ? "live" : "test",
-                balance: balData.available?.map((b) => ({
-                    amount: (b.amount / 100).toFixed(2),
-                    currency: b.currency.toUpperCase(),
-                })) ?? [],
-                recentTransactions: transactions.length,
-                totalGross: (totalGross / 100).toFixed(2),
-                totalFees: (totalFees / 100).toFixed(2),
-                totalNet: (totalNet / 100).toFixed(2),
-                feePercentage: totalGross > 0 ? ((totalFees / totalGross) * 100).toFixed(1) + "%" : "N/A",
-            };
-        }
-        catch (err) {
-            costs.stripe = { error: err.message };
-        }
-    }
-    // Vercel usage
-    if (process.env.VERCEL_TOKEN) {
-        try {
-            // Get team/user info for billing context
-            const userRes = await fetch("https://api.vercel.com/v2/user", {
-                headers: { Authorization: `Bearer ${process.env.VERCEL_TOKEN}` },
-            });
-            const userData = await userRes.json();
-            // Count deployments
-            const depRes = await fetch("https://api.vercel.com/v6/deployments?limit=100", {
-                headers: { Authorization: `Bearer ${process.env.VERCEL_TOKEN}` },
-            });
-            const depData = await depRes.json();
-            const deployments = depData.deployments ?? [];
-            // Deployments this month
-            const monthStart = new Date();
-            monthStart.setDate(1);
-            monthStart.setHours(0, 0, 0, 0);
-            const thisMonth = deployments.filter((d) => new Date(d.created) >= monthStart);
-            costs.vercel = {
-                plan: userData.user?.billing?.plan ?? "unknown",
-                deploymentsThisMonth: thisMonth.length,
-                totalDeployments: deployments.length,
-                note: "Vercel free tier includes 100 deployments/day. Check vercel.com/dashboard for detailed billing.",
-            };
-        }
-        catch { /* skip */ }
-    }
-    // Supabase usage estimate
-    if (process.env.SUPABASE_URL && process.env.SUPABASE_SERVICE_KEY) {
-        const url = process.env.SUPABASE_URL;
-        const key = process.env.SUPABASE_SERVICE_KEY;
-        const headers = {
-            apikey: key,
-            Authorization: `Bearer ${key}`,
-            Prefer: "count=exact",
-        };
-        const tableCounts = {};
-        for (const table of ["posts", "users", "payments"]) {
-            try {
-                const res = await fetch(`${url}/rest/v1/${table}?select=id&limit=0`, { headers });
-                const range = res.headers.get("content-range");
-                tableCounts[table] = range ? parseInt(range.split("/")[1]) || 0 : null;
-            }
-            catch {
-                tableCounts[table] = null;
-            }
-        }
-        const totalRows = Object.values(tableCounts).reduce((s, v) => s + (v ?? 0), 0);
-        costs.supabase = {
-            tables: tableCounts,
-            totalRows,
-            note: "Supabase free tier: 500MB database, 1GB storage, 50k monthly active users. Check supabase.com/dashboard for detailed usage.",
-        };
-    }
-    return {
-        content: [{ type: "text", text: JSON.stringify({ costs }, null, 2) }],
-    };
-});
-// ──────────────────────────────────────────
-// Brain: Supabase Knowledge Base Client
-// ──────────────────────────────────────────
-function getBrainClient() {
-    return getLocalBrainClient();
-}
-// ──────────────────────────────────────────
-// Tool: stk_brain_search
-// ──────────────────────────────────────────
-server.tool("stk_brain_search", "Search the knowledge base for SaaS patterns, best practices, and architecture examples from top open-source projects (LangChain, Ollama, Transformers, llama.cpp, vLLM, AutoGen, OpenAI Cookbook). Use this when you need to know how successful projects solve specific problems.", {
-    query: z.string().describe("What to search for (e.g., 'authentication', 'real-time updates', 'payment integration')"),
-    category: z.string().optional().describe("Filter: architecture, auth, payments, database, api, deployment, testing, performance, security, ml, realtime, general"),
-}, async ({ query, category }) => {
-    const brain = getBrainClient();
-    // Try ilike search on content and title
-    const words = query.split(" ").filter(w => w.length > 2);
-    const searchWord = words[0] ?? query;
-    const params = {
-        or: `(title.ilike.%${searchWord}%,content.ilike.%${searchWord}%)`,
-        limit: "10",
-        order: "source",
-    };
-    if (category)
-        params["category"] = `eq.${category}`;
-    const { data, ok } = await brain.query("knowledge", params);
-    if (!ok)
-        return { content: [{ type: "text", text: JSON.stringify({ error: "Query failed", data }) }] };
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    query,
-                    results: (data ?? []).map((r) => ({ source: r.source, category: r.category, title: r.title, content: r.content, tags: r.tags })),
-                    total: data?.length ?? 0,
-                }, null, 2),
-            }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_brain_patterns
-// ──────────────────────────────────────────
-server.tool("stk_brain_patterns", "Get best practice patterns for a specific feature. Returns how top projects implement auth, payments, real-time, caching, APIs, etc.", {
-    feature: z.string().describe("The feature or pattern (e.g., 'authentication', 'webhooks', 'caching', 'model serving', 'fine-tuning')"),
-}, async ({ feature }) => {
-    const brain = getBrainClient();
-    const { data, ok } = await brain.query("knowledge", {
-        or: `(title.ilike.%${feature}%,content.ilike.%${feature}%)`,
-        limit: "15",
-        order: "source",
-    });
-    if (!ok)
-        return { content: [{ type: "text", text: JSON.stringify({ error: "Query failed" }) }] };
-    // Group by source
-    const grouped = {};
-    for (const item of data ?? []) {
-        if (!grouped[item.source])
-            grouped[item.source] = [];
-        grouped[item.source].push({ title: item.title, category: item.category, content: item.content });
-    }
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    feature,
-                    patterns: grouped,
-                    totalSources: Object.keys(grouped).length,
-                    totalPatterns: data?.length ?? 0,
-                }, null, 2),
-            }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_brain_stack
-// ──────────────────────────────────────────
-server.tool("stk_brain_stack", "Get recommendations specific to YOUR stack (Supabase + Vercel + Stripe + Node.js). Filters knowledge for patterns matching your technology choices.", {
-    question: z.string().describe("What you want to build or solve (e.g., 'add user auth', 'implement webhooks', 'optimize queries')"),
-}, async ({ question }) => {
-    const brain = getBrainClient();
-    const words = question.split(" ").filter(w => w.length > 3);
-    const searchWord = words[0] ?? question;
-    const { data, ok } = await brain.query("knowledge", {
-        or: `(content.ilike.%${searchWord}%,title.ilike.%${searchWord}%)`,
-        limit: "10",
-    });
-    if (!ok)
-        return { content: [{ type: "text", text: JSON.stringify({ error: "Query failed" }) }] };
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    question,
-                    stack: ["Supabase", "Vercel", "Stripe", "Node.js/Express"],
-                    recommendations: (data ?? []).map((r) => ({ source: r.source, title: r.title, content: r.content, relevance: r.category })),
-                    total: data?.length ?? 0,
-                }, null, 2),
-            }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_brain_learn
-// ──────────────────────────────────────────
-server.tool("stk_brain_learn", "Save new knowledge to the brain. Use this to remember patterns, solutions, or learnings for future reference across all projects.", {
-    title: z.string().describe("Short title"),
-    content: z.string().describe("The knowledge — pattern, solution, or best practice"),
-    source: z.string().optional().describe("Where this came from (e.g., 'project:worldchat', 'github:vercel/next.js')"),
-    category: z.string().optional().describe("Category: architecture, auth, payments, database, api, deployment, testing, performance, security, ml, general"),
-    tags: z.array(z.string()).optional().describe("Tags for searchability"),
-}, async ({ title, content, source, category, tags }) => {
-    const brain = getBrainClient();
-    const { data, ok } = await brain.insert("knowledge", {
-        title,
-        content,
-        source: source ?? "manual",
-        category: category ?? "general",
-        tags: tags ?? [],
-        created_at: new Date().toISOString(),
-    });
-    if (!ok)
-        return { content: [{ type: "text", text: JSON.stringify({ error: "Insert failed", data }) }] };
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({ learned: true, title, message: "Knowledge saved. I can recall this in future conversations." }, null, 2),
-            }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_brain_stats
-// ──────────────────────────────────────────
-server.tool("stk_brain_stats", "Check what the brain knows — total knowledge entries, categories, sources, and coverage.", {}, async () => {
-    const brain = getBrainClient();
-    const { data, count } = await brain.query("knowledge", { select: "category,source", limit: "1000" });
-    const categories = {};
-    const sources = {};
-    for (const row of data ?? []) {
-        categories[row.category] = (categories[row.category] || 0) + 1;
-        sources[row.source] = (sources[row.source] || 0) + 1;
-    }
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    totalKnowledge: count ?? data?.length ?? 0,
-                    categories,
-                    sources,
-                    topSources: Object.entries(sources)
-                        .sort(([, a], [, b]) => b - a)
-                        .slice(0, 10)
-                        .map(([name, count]) => ({ name, count })),
-                }, null, 2),
-            }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_brain_check
-// ──────────────────────────────────────────
-server.tool("stk_brain_check", "PROACTIVE GOTCHA DETECTION — Run this BEFORE implementing any feature or fixing any bug. Searches the brain for known gotchas, pitfalls, and patterns related to your task. Returns warnings ranked by relevance so you can avoid repeating past mistakes. Claude should call this automatically before writing code.", {
-    task: z.string().describe("What you're about to implement or fix (e.g., 'add email verification', 'update user model', 'fix auth redirect')"),
-}, async ({ task }) => {
-    const results = brainCheck(task);
-    if (results.length === 0) {
-        return {
-            content: [{
-                    type: "text",
-                    text: JSON.stringify({
-                        task,
-                        warnings: [],
-                        message: "No known gotchas found. Proceed with caution — this might be new territory.",
-                    }, null, 2),
-                }],
-        };
-    }
-    const warnings = results.slice(0, 5).map(r => ({
-        title: r.entry.title,
-        content: r.entry.content,
-        relevance: r.score,
-        matchedTerms: r.matchedTerms,
-        source: r.entry.source,
-        category: r.entry.category,
-    }));
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    task,
-                    warnings,
-                    totalMatches: results.length,
-                    message: `Found ${results.length} relevant pattern(s). Review warnings before coding.`,
-                }, null, 2),
-            }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_brain_diagnose
-// ──────────────────────────────────────────
-server.tool("stk_brain_diagnose", "ERROR PATTERN MATCHING — Run this when you encounter an error or bug. Searches the brain for matching patterns from past issues and returns known solutions. Claude should call this automatically when debugging.", {
-    error: z.string().describe("The error message, symptom, or bug description (e.g., 'redirect not working after verification', 'emails not sending', 'prisma field undefined')"),
-}, async ({ error }) => {
-    const results = brainDiagnose(error);
-    if (results.length === 0) {
-        return {
-            content: [{
-                    type: "text",
-                    text: JSON.stringify({
-                        error,
-                        solutions: [],
-                        message: "No matching patterns found. This is a new issue — after fixing it, use stk_brain_learn to save the pattern.",
-                    }, null, 2),
-                }],
-        };
-    }
-    const solutions = results.slice(0, 5).map(r => ({
-        title: r.entry.title,
-        solution: r.entry.content,
-        relevance: r.score,
-        matchedTerms: r.matchedTerms,
-        source: r.entry.source,
-    }));
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    error,
-                    solutions,
-                    totalMatches: results.length,
-                    message: `Found ${results.length} matching pattern(s). Apply relevant solutions.`,
-                }, null, 2),
-            }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_brain_ingest
-// ──────────────────────────────────────────
-server.tool("stk_brain_ingest", "Scan the current project and ingest architecture knowledge into the local brain (~/.stk/brain.json). Automatically reads CLAUDE.md, package.json, Prisma schema, Dockerfile, CI config, and route files. Run this when setting up stk in a new project or after major changes.", {
-    force: z.boolean().optional().default(false).describe("Re-ingest even if already ingested"),
-}, async ({ force }) => {
-    const store = loadBrainStore();
-    const { projectName, entries, filesScanned } = ingestProject(process.cwd());
-    if (store.projects[projectName] && !force) {
-        const existing = store.projects[projectName];
-        return {
-            content: [{
-                    type: "text",
-                    text: JSON.stringify({
-                        alreadyIngested: true,
-                        projectName,
-                        entries: existing.entries.length,
-                        ingestedAt: existing.ingestedAt,
-                        message: "Already ingested. Use force: true to re-ingest.",
-                    }, null, 2),
-                }],
-        };
-    }
-    if (entries.length === 0) {
-        return {
-            content: [{
-                    type: "text",
-                    text: JSON.stringify({ error: "No knowledge extracted. Make sure you're in a project directory with recognizable files." }),
-                }],
-        };
-    }
-    store.projects[projectName] = {
-        ingestedAt: new Date().toISOString(),
-        projectPath: process.cwd(),
-        entries,
-    };
-    saveBrainStore(store);
-    const categories = {};
-    for (const e of entries) {
-        categories[e.category] = (categories[e.category] || 0) + 1;
-    }
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    ingested: true,
-                    projectName,
-                    totalEntries: entries.length,
-                    filesScanned,
-                    categories,
-                    storedAt: "~/.stk/brain.json",
-                }, null, 2),
-            }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_brain_sync
-// ──────────────────────────────────────────
-server.tool("stk_brain_sync", "Sync brain knowledge between local (~/.stk/brain.json) and cloud (Supabase). Push shares your knowledge with other developers. Pull downloads knowledge from the cloud. Sync does both.", {
-    action: z.enum(["sync", "push", "pull"]).optional().default("sync").describe("sync: push+pull, push: local→cloud, pull: cloud→local"),
-}, async ({ action }) => {
-    let result;
-    if (action === "push")
-        result = await pushToCloud();
-    else if (action === "pull")
-        result = await pullFromCloud();
-    else
-        result = await syncBrain();
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    action,
-                    pushed: result.pushed,
-                    pulled: result.pulled,
-                    errors: result.errors.length > 0 ? result.errors : undefined,
-                    ok: result.errors.length === 0,
-                }, null, 2),
-            }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_brain_check (PROACTIVE — call before writing code)
-// ──────────────────────────────────────────
-server.tool("stk_brain_check", "PROACTIVE: Call this BEFORE implementing a feature or making changes. Searches the brain for known gotchas, past bugs, and patterns relevant to what you're about to build. Returns warnings that can prevent mistakes. Use this whenever you start a non-trivial coding task.", {
-    task: z.string().describe("What you're about to implement (e.g., 'add email verification', 'update user model', 'add webhook endpoint')"),
-}, async ({ task }) => {
-    const results = brainCheck(task);
-    if (results.length === 0) {
-        return {
-            content: [{
-                    type: "text",
-                    text: JSON.stringify({
-                        task,
-                        warnings: [],
-                        message: "No known gotchas found. Proceed carefully.",
-                    }, null, 2),
-                }],
-        };
-    }
-    const warnings = results.slice(0, 8).map(r => ({
-        title: r.entry.title,
-        warning: r.entry.content,
-        relevance: r.score,
-        matchedTerms: r.matchedTerms,
-        source: r.entry.source,
-        category: r.entry.category,
-    }));
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    task,
-                    warnings,
-                    totalMatches: results.length,
-                    message: `Found ${results.length} relevant entries. Review warnings before coding.`,
-                }, null, 2),
-            }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_brain_diagnose (REACTIVE — call when you hit an error)
-// ──────────────────────────────────────────
-server.tool("stk_brain_diagnose", "REACTIVE: Call this when you encounter an error or bug. Searches the brain for matching patterns from past issues and returns known solutions. Use this before debugging from scratch — the answer may already be in the brain.", {
-    error: z.string().describe("The error message, bug description, or unexpected behavior you're seeing"),
-}, async ({ error }) => {
-    const results = brainDiagnose(error);
-    if (results.length === 0) {
-        return {
-            content: [{
-                    type: "text",
-                    text: JSON.stringify({
-                        error,
-                        solutions: [],
-                        message: "No matching patterns found in the brain. This is a new issue — debug it, fix it, then use stk_brain_learn to save the solution.",
-                    }, null, 2),
-                }],
-        };
-    }
-    const solutions = results.slice(0, 5).map(r => ({
-        title: r.entry.title,
-        solution: r.entry.content,
-        relevance: r.score,
-        matchedTerms: r.matchedTerms,
-        source: r.entry.source,
-    }));
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    error,
-                    solutions,
-                    totalMatches: results.length,
-                    message: `Found ${results.length} matching patterns. Apply the most relevant solution.`,
-                }, null, 2),
-            }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_brain_claudemd
-// ──────────────────────────────────────────
-server.tool("stk_brain_claudemd", "Auto-generate a CLAUDE.md file for the current project. Analyzes the tech stack, project structure, services, and brain knowledge to create comprehensive project instructions for Claude Code.", {
-    projectName: z.string().optional().describe("Project name (auto-detected from stk.config.json if omitted)"),
-    write: z.boolean().optional().default(false).describe("Actually write the CLAUDE.md file to disk. If false, just returns the content for review."),
-}, async ({ projectName, write }) => {
-    const config = loadConfig();
-    const name = projectName ?? config.name ?? "my-project";
-    const enabled = enabledServices(config);
-    // Detect project info
-    let gitBranch = "";
-    let gitRemote = "";
-    let packageJson = {};
-    try {
-        gitBranch = execSync("git rev-parse --abbrev-ref HEAD", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    }
-    catch { }
-    try {
-        gitRemote = execSync("git remote get-url origin", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    }
-    catch { }
-    try {
-        const { readFileSync } = await import("fs");
-        packageJson = JSON.parse(readFileSync("package.json", "utf-8"));
-    }
-    catch { }
-    // Detect tech stack
-    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
-    const stack = [];
-    if (deps?.["next"])
-        stack.push("Next.js");
-    if (deps?.["react"])
-        stack.push("React");
-    if (deps?.["vue"])
-        stack.push("Vue");
-    if (deps?.["express"])
-        stack.push("Express.js");
-    if (deps?.["fastify"])
-        stack.push("Fastify");
-    if (deps?.["@supabase/supabase-js"])
-        stack.push("Supabase");
-    if (deps?.["stripe"])
-        stack.push("Stripe");
-    if (deps?.["prisma"] || deps?.["@prisma/client"])
-        stack.push("Prisma");
-    if (deps?.["mongoose"])
-        stack.push("Mongoose/MongoDB");
-    if (deps?.["redis"] || deps?.["ioredis"])
-        stack.push("Redis");
-    if (deps?.["tailwindcss"])
-        stack.push("Tailwind CSS");
-    if (deps?.["typescript"])
-        stack.push("TypeScript");
-    if (deps?.["zod"])
-        stack.push("Zod");
-    if (stack.length === 0 && Object.keys(deps ?? {}).length > 0) {
-        stack.push("Node.js");
-    }
-    // Detect file structure
-    let fileStructure = "";
-    try {
-        fileStructure = execSync("find . -maxdepth 3 -type f -name '*.ts' -o -name '*.js' -o -name '*.tsx' -o -name '*.jsx' -o -name '*.json' -o -name '*.css' -o -name '*.html' | grep -v node_modules | grep -v dist | grep -v .git | sort | head -40", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    }
-    catch { }
-    // Build CLAUDE.md
-    const lines = [];
-    lines.push(`# ${name}\n`);
-    // Project overview
-    lines.push(`## Overview\n`);
-    if (packageJson.description)
-        lines.push(`${packageJson.description}\n`);
-    if (stack.length > 0)
-        lines.push(`**Tech Stack:** ${stack.join(", ")}\n`);
-    if (gitRemote)
-        lines.push(`**Repo:** ${gitRemote}`);
-    if (gitBranch)
-        lines.push(`**Main Branch:** ${gitBranch}`);
-    lines.push("");
-    // Services
-    if (enabled.length > 0) {
-        lines.push(`## Services\n`);
-        for (const svc of enabled) {
-            const svcName = svc.charAt(0).toUpperCase() + svc.slice(1);
-            lines.push(`- **${svcName}** — configured and monitored via stk`);
-        }
-        lines.push("");
-    }
-    // Project structure
-    if (fileStructure) {
-        lines.push(`## Project Structure\n`);
-        lines.push("```");
-        lines.push(fileStructure);
-        lines.push("```\n");
-    }
-    // Development commands
-    lines.push(`## Development\n`);
-    if (packageJson.scripts) {
-        lines.push("```bash");
-        if (packageJson.scripts.dev)
-            lines.push(`npm run dev        # Start dev server`);
-        if (packageJson.scripts.build)
-            lines.push(`npm run build      # Build for production`);
-        if (packageJson.scripts.test)
-            lines.push(`npm test           # Run tests`);
-        if (packageJson.scripts.start)
-            lines.push(`npm start          # Start production server`);
-        lines.push("```\n");
-    }
-    // stk tools available
-    lines.push(`## stk Tools Available\n`);
-    lines.push(`This project uses stk for infrastructure monitoring. Available commands:\n`);
-    lines.push(`- \`stk_health\` — Check service health`);
-    lines.push(`- \`stk_status\` — Full project overview`);
-    lines.push(`- \`stk_logs\` — Production logs`);
-    lines.push(`- \`stk_db\` — Query database`);
-    lines.push(`- \`stk_alerts\` — Check for problems`);
-    lines.push(`- \`stk_deploy\` — Deploy to production`);
-    lines.push(`- \`stk_brain_search\` — Search knowledge base`);
-    lines.push(`- \`stk_brain_learn\` — Save patterns for future use`);
-    lines.push("");
-    // Conventions
-    lines.push(`## Conventions\n`);
-    if (deps?.["typescript"]) {
-        lines.push(`- TypeScript strict mode enabled`);
-    }
-    lines.push(`- Use existing patterns in the codebase before introducing new ones`);
-    lines.push(`- Check stk_health before debugging production issues`);
-    lines.push(`- Use stk_brain_search to find how other projects solve similar problems`);
-    lines.push(`- Save useful patterns with stk_brain_learn for future reference`);
-    lines.push("");
-    // Environment
-    lines.push(`## Environment Variables\n`);
-    lines.push(`Environment variables are managed via \`.env\` files. See \`.env.example\` for required variables.`);
-    if (enabled.includes("vercel"))
-        lines.push(`Use \`stk_env_sync\` to compare local vs remote env vars.`);
-    lines.push("");
-    const content = lines.join("\n");
-    if (write) {
-        const { writeFileSync } = await import("fs");
-        writeFileSync("CLAUDE.md", content);
-        return {
-            content: [{
-                    type: "text",
-                    text: JSON.stringify({ written: true, path: "CLAUDE.md", lines: content.split("\n").length }, null, 2),
-                }],
-        };
-    }
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({ preview: true, content, note: "Call again with write: true to save to disk" }, null, 2),
-            }],
-    };
-});
-// Helper
-function detectGitHubRepo() {
-    try {
-        const url = execSync("git remote get-url origin", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-        const match = url.match(/github\.com[:/]([^/]+\/[^/.]+)/);
-        return match?.[1] ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-// ──────────────────────────────────────────
-// Tool: stk_autofix
-// ──────────────────────────────────────────
-server.tool("stk_autofix", "Auto-diagnose errors from production logs. Fetches recent logs, extracts errors, and searches the brain for matching solutions. Returns errors with matched fix patterns and confidence scores.", {
-    provider: z.enum(["railway", "vercel"]).optional(),
-    lines: z.number().optional().default(50),
-}, async ({ provider, lines }) => {
-    // Determine provider
-    const config = loadConfig();
-    const detected = provider ?? (enabledServices(config).includes("railway") ? "railway" : "vercel");
-    // Fetch logs using existing stk_logs logic (inline)
-    let logs = [];
-    try {
-        if (detected === "railway") {
-            const token = process.env.RAILWAY_API_TOKEN;
-            const projectId = process.env.RAILWAY_PROJECT_ID;
-            const serviceId = process.env.RAILWAY_SERVICE_ID;
-            if (token && projectId && serviceId) {
-                const envId = process.env.RAILWAY_ENVIRONMENT_ID;
-                const gql = `query { deployments(first:1, input:{projectId:"${projectId}",serviceId:"${serviceId}"${envId ? `,environmentId:"${envId}"` : ""}}) { edges { node { id } } } }`;
-                const depRes = await fetch("https://backboard.railway.app/graphql/v2", {
-                    method: "POST",
-                    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
-                    body: JSON.stringify({ query: gql }),
-                });
-                const depData = await depRes.json();
-                const depId = (depData?.data?.deployments?.edges?.[0]?.node?.id) ?? null;
-                if (depId) {
-                    const logGql = `query { deploymentLogs(deploymentId:"${depId}",limit:${lines}) { timestamp message severity } }`;
-                    const logRes = await fetch("https://backboard.railway.app/graphql/v2", {
-                        method: "POST",
-                        headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
-                        body: JSON.stringify({ query: logGql }),
-                    });
-                    const logData = await logRes.json();
-                    logs = (logData?.data?.deploymentLogs ?? []);
-                }
-            }
-        }
-    }
-    catch { /* log fetch failed */ }
-    // Filter for errors
-    const errorPattern = /error|exception|fail|crash|ECONNREFUSED|timeout|TypeError|ReferenceError|rejected|FATAL/i;
-    const errorLogs = logs.filter(l => l.severity === "error" || (l.message && errorPattern.test(l.message)));
-    // Deduplicate by first 100 chars
-    const grouped = new Map();
-    for (const log of errorLogs) {
-        const key = log.message.slice(0, 100);
-        const existing = grouped.get(key);
-        if (existing) {
-            existing.count++;
-            existing.lastSeen = log.timestamp;
-        }
-        else {
-            grouped.set(key, { message: log.message, count: 1, firstSeen: log.timestamp, lastSeen: log.timestamp });
-        }
-    }
-    // Diagnose each unique error
-    const errors = [];
-    let matchedErrors = 0;
-    for (const error of grouped.values()) {
-        const matches = brainDiagnose(error.message);
-        const solutions = matches.slice(0, 3).map(m => ({
-            title: m.entry.title,
-            content: m.entry.content.slice(0, 400),
-            confidence: Math.min(1, m.score / 10),
-            source: m.entry.source,
-        }));
-        if (solutions.length > 0)
-            matchedErrors++;
-        errors.push({ ...error, solutions });
-    }
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    provider: detected,
-                    errors,
-                    summary: {
-                        totalErrors: errorLogs.length,
-                        uniqueErrors: grouped.size,
-                        matchedErrors,
-                        unmatchedErrors: grouped.size - matchedErrors,
-                    },
-                }, null, 2),
-            }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_brain_review
-// ──────────────────────────────────────────
-server.tool("stk_brain_review", "Review code changes against the brain's knowledge base. Checks a git diff or PR for known gotchas per file. Use before merging PRs or after making changes.", {
-    diff: z.string().optional().describe("Raw git diff output"),
-    pr: z.number().optional().describe("GitHub PR number to review"),
-}, async ({ diff, pr }) => {
-    let diffContent = diff ?? "";
-    // If PR number, fetch diff from GitHub
-    if (pr && !diff) {
-        const token = process.env.GITHUB_TOKEN;
-        let repo = process.env.GITHUB_REPO ?? "";
-        if (!repo) {
-            try {
-                repo = execSync("git remote get-url origin", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim().replace(/.*github\.com[:/]/, "").replace(/\.git$/, "");
-            }
-            catch { /* */ }
-        }
-        if (repo && token) {
-            try {
-                const res = await fetch(`https://api.github.com/repos/${repo}/pulls/${pr}`, {
-                    headers: { Authorization: `Bearer ${token}`, Accept: "application/vnd.github.diff" },
-                });
-                if (res.ok)
-                    diffContent = await res.text();
-            }
-            catch { /* */ }
-        }
-    }
-    // If no diff provided, get latest commit diff
-    if (!diffContent) {
-        try {
-            diffContent = execSync("git diff HEAD~1", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], maxBuffer: 1024 * 1024 * 5 });
-        }
-        catch { /* */ }
-    }
-    if (!diffContent) {
-        return { content: [{ type: "text", text: JSON.stringify({ error: "No diff available. Provide diff text, PR number, or ensure you're in a git repo." }) }] };
-    }
-    const results = reviewDiff(diffContent);
-    const filesWithWarnings = results.filter(r => r.warnings.length > 0);
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    files: results,
-                    summary: {
-                        filesReviewed: results.length,
-                        filesWithWarnings: filesWithWarnings.length,
-                        totalWarnings: filesWithWarnings.reduce((s, r) => s + r.warnings.length, 0),
-                    },
-                }, null, 2),
-            }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_metrics
-// ──────────────────────────────────────────
-server.tool("stk_metrics", "Track and analyze infrastructure metrics over time — deploy frequency, error rates, response times, uptime. Compare current performance against historical baselines to detect regressions.", {
-    action: z.enum(["view", "record", "compare"]).optional().default("view"),
-    type: z.enum(["deploy", "health_check", "error", "response_time"]).optional(),
-    value: z.number().optional(),
-    metadata: z.record(z.string(), z.string()).optional(),
-    days: z.number().optional().default(7),
-}, async ({ action, type, value, metadata, days }) => {
-    if (action === "record" && type && value !== undefined) {
-        recordMetric(type, value, metadata ?? {});
-        return { content: [{ type: "text", text: JSON.stringify({ recorded: true, type, value }) }] };
-    }
-    if (action === "compare") {
-        const types = ["deploy", "health_check", "error", "response_time"];
-        const comparisons = types.map(t => ({ type: t, ...compareToBaseline(t) }));
-        const degraded = comparisons.filter(c => c.status === "degraded");
-        return {
-            content: [{
-                    type: "text",
-                    text: JSON.stringify({
-                        comparisons,
-                        degraded: degraded.length > 0 ? degraded : "none",
-                        summary: `${degraded.length} metric(s) degraded`,
-                    }, null, 2),
-                }],
-        };
-    }
-    // Default: view
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    period: `${days} days`,
-                    deploys: getDeployFrequency(days),
-                    errors: getErrorRate(days),
-                    uptime: getUptime(days),
-                    recentMetrics: getMetrics(type ?? undefined, days, 20),
-                }, null, 2),
-            }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_secure
-// ──────────────────────────────────────────
-server.tool("stk_secure", "Security scan — check for exposed secrets, vulnerable dependencies, missing rate limiting, open CORS, and unprotected routes. Returns findings with severity levels and fix suggestions.", {
-    checks: z.array(z.enum(["secrets", "deps", "rate_limit", "cors", "auth"])).optional().describe("Specific checks to run (default: all)"),
-}, async ({ checks }) => {
-    const findings = runAllChecks(checks);
-    const critical = findings.filter(f => f.level === "critical").length;
-    const warning = findings.filter(f => f.level === "warning").length;
-    const info = findings.filter(f => f.level === "info").length;
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    findings,
-                    summary: { critical, warning, info, total: findings.length },
-                    status: critical > 0 ? "CRITICAL" : warning > 0 ? "WARNING" : "CLEAN",
-                }, null, 2),
-            }],
-    };
-});
-// ──────────────────────────────────────────
-// Tool: stk_brain_team
-// ──────────────────────────────────────────
-server.tool("stk_brain_team", "Show team brain contributions — who learned what, from which projects, and when. Tracks knowledge sharing across team members.", {}, async () => {
-    const store = loadBrainStore();
-    const allEntries = [...store.global];
-    for (const proj of Object.values(store.projects))
-        allEntries.push(...proj.entries);
-    const contributors = {};
-    for (const entry of allEntries) {
-        const contributor = entry.contributor ?? "auto";
-        if (!contributors[contributor]) {
-            contributors[contributor] = { count: 0, lastActive: entry.created_at, categories: {} };
-        }
-        contributors[contributor].count++;
-        if (entry.created_at > contributors[contributor].lastActive) {
-            contributors[contributor].lastActive = entry.created_at;
-        }
-        contributors[contributor].categories[entry.category] = (contributors[contributor].categories[entry.category] || 0) + 1;
-    }
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    totalEntries: allEntries.length,
-                    contributors,
-                    projects: Object.entries(store.projects).map(([name, p]) => ({
-                        name, entries: p.entries.length, ingestedAt: p.ingestedAt,
-                    })),
-                }, null, 2),
-            }],
-    };
-});
+    version: "0.7.0",
+});
+registerInfraTools(server);
+registerOpsTools(server);
+registerDataTools(server);
+registerBrainTools(server);
+registerGithubTools(server);
+registerSecurityTools(server);
 // Start
 async function main() {
     const transport = new StdioServerTransport();