@prajwolkc/stk 0.6.1 → 0.7.1

package/dist/mcp/tools/data.js

@@ -0,0 +1,385 @@
+import { z } from "zod";
+import { recordMetric, getMetrics, compareToBaseline, getDeployFrequency, getErrorRate, getUptime } from "../../services/metrics.js";
+export function registerDataTools(server) {
+    // ──────────────────────────────────────────
+    // 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 instanceof Error ? err.message : String(err) }) }] };
+        }
+    });
+    // ──────────────────────────────────────────
+    // 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 instanceof Error ? err.message : String(err) };
+            }
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify({ analytics: results }, null, 2) }],
+        };
+    });
+    // ──────────────────────────────────────────
+    // 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 instanceof Error ? err.message : String(err) };
+            }
+        }
+        // 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) }],
+        };
+    });
+    // ──────────────────────────────────────────
+    // 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),
+                }],
+        };
+    });
+} // end registerDataTools

package/dist/mcp/tools/github.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerGithubTools(server: McpServer): void;

package/dist/mcp/tools/github.js

@@ -0,0 +1,95 @@
+import { z } from "zod";
+import { loadConfig } from "../../lib/config.js";
+import { execSync } from "child_process";
+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;
+    }
+}
+export function registerGithubTools(server) {
+    // ──────────────────────────────────────────
+    // 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) }],
+        };
+    });
+} // end registerGithubTools

package/dist/mcp/tools/infra.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerInfraTools(server: McpServer): void;