@prajwolkc/stk 0.5.1 → 0.7.0

package/dist/commands/brain.js

@@ -1,11 +1,44 @@
 import { Command } from "commander";
 import chalk from "chalk";
 import ora from "ora";
-import { syncBrain, pushToCloud, pullFromCloud, loadBrainStore, getAllEntries } from "../services/brain.js";
+import { syncBrain, pushToCloud, pullFromCloud, loadBrainStore, getAllEntries, seedBrain } from "../services/brain.js";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
 export const brainCommand = new Command("brain")
     .description("Manage the stk knowledge brain — sync, push, pull across machines")
-    .argument("[action]", "push | pull | sync | stats (default: sync)")
-    .action(async (action = "sync") => {
+    .argument("[action]", "push | pull | sync | stats | seed (default: sync)")
+    .option("--force", "force re-seed (replace existing seed entries)")
+    .action(async (action = "sync", _extra, cmd) => {
+    const opts = cmd?.opts?.() ?? {};
+    if (action === "seed") {
+        const spinner = ora("  Loading seed patterns...").start();
+        try {
+            const __filename = fileURLToPath(import.meta.url);
+            const __dirname = dirname(__filename);
+            // Data lives in src/data (shipped with npm), not dist/data
+            const seedPath = join(__dirname, "..", "..", "src", "data", "seed-patterns.json");
+            const patterns = JSON.parse(readFileSync(seedPath, "utf-8"));
+            spinner.text = `  Seeding ${patterns.length} patterns...`;
+            const { added, skipped } = seedBrain(patterns, opts.force);
+            spinner.succeed(`  Seeded ${chalk.white(added)} patterns (${skipped} already existed)`);
+            console.log();
+            const categories = {};
+            for (const p of patterns)
+                categories[p.category] = (categories[p.category] || 0) + 1;
+            console.log(chalk.bold("  Patterns by category:"));
+            for (const [cat, count] of Object.entries(categories).sort(([, a], [, b]) => b - a)) {
+                console.log(`  ${chalk.dim("●")} ${cat}: ${count}`);
+            }
+            console.log();
+        }
+        catch (err) {
+            spinner.fail("  Seed failed");
+            console.log(`  ${chalk.red(err instanceof Error ? err.message : String(err))}`);
+            console.log();
+        }
+        return;
+    }
     if (action === "stats") {
         const store = loadBrainStore();
         const projects = Object.entries(store.projects);

package/dist/mcp/server.js

@@ -11,7 +11,9 @@ 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 } from "../services/brain.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";
 const server = new McpServer({
     name: "stk",
@@ -1163,6 +1165,83 @@ server.tool("stk_brain_stats", "Check what the brain knows — total knowledge e
     };
 });
 // ──────────────────────────────────────────
+// 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.", {
@@ -1244,6 +1323,83 @@ server.tool("stk_brain_sync", "Sync brain knowledge between local (~/.stk/brain.
     };
 });
 // ──────────────────────────────────────────
+// 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.", {
@@ -1409,6 +1565,246 @@ function detectGitHubRepo() {
         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),
+            }],
+    };
+});
 // Start
 async function main() {
     const transport = new StdioServerTransport();

package/dist/services/brain.d.ts

@@ -63,4 +63,36 @@ export declare function pushToCloud(): Promise<SyncResult>;
 export declare function pullFromCloud(): Promise<SyncResult>;
 /** Full sync: push local → cloud, then pull cloud → local */
 export declare function syncBrain(): Promise<SyncResult>;
+interface ScoredEntry {
+    entry: KnowledgeEntry;
+    score: number;
+    matchedTerms: string[];
+}
+/** Search brain with relevance scoring — returns entries ranked by how many terms match */
+export declare function smartSearch(terms: string[], category?: string): ScoredEntry[];
+/** Extract relevant terms from a task description */
+export declare function extractTerms(description: string): string[];
+/** Proactive check — find gotchas relevant to a task before coding */
+export declare function brainCheck(taskDescription: string): ScoredEntry[];
+/** Diagnose an error — find matching patterns from past issues */
+export declare function brainDiagnose(error: string): ScoredEntry[];
+/** Seed brain with curated patterns (idempotent) */
+export declare function seedBrain(patterns: KnowledgeEntry[], force?: boolean): {
+    added: number;
+    skipped: number;
+};
+/** Review a diff against brain knowledge — find gotchas per file */
+export interface ReviewWarning {
+    file: string;
+    linesChanged: number;
+    warnings: Array<{
+        title: string;
+        content: string;
+        relevance: number;
+        source: string;
+    }>;
+}
+export declare function reviewDiff(diff: string): ReviewWarning[];
+/** Get contributor name from git config */
+export declare function getContributor(): string;
 export {};