@prajwolkc/stk 0.4.1 → 0.5.0

package/dist/commands/brain.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const brainCommand: Command;

package/dist/commands/brain.js

@@ -0,0 +1,69 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { syncBrain, pushToCloud, pullFromCloud, loadBrainStore, getAllEntries } from "../services/brain.js";
+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") => {
+    if (action === "stats") {
+        const store = loadBrainStore();
+        const projects = Object.entries(store.projects);
+        const totalEntries = getAllEntries(store).length;
+        console.log();
+        console.log(chalk.bold("  Brain Stats"));
+        console.log(chalk.dim("  ─────────────────────────────────────────"));
+        console.log(`  Total entries:   ${chalk.white(totalEntries)}`);
+        console.log(`  Global entries:  ${chalk.white(store.global.length)}`);
+        console.log(`  Projects:        ${chalk.white(projects.length)}`);
+        console.log();
+        for (const [name, proj] of projects) {
+            console.log(`  ${chalk.green("●")} ${chalk.bold(name)} — ${proj.entries.length} entries (${proj.ingestedAt})`);
+        }
+        if (projects.length === 0) {
+            console.log(chalk.dim("  No projects ingested yet. Run: stk ingest"));
+        }
+        console.log();
+        return;
+    }
+    if (!["push", "pull", "sync"].includes(action)) {
+        console.log(chalk.red(`  Unknown action: "${action}"`));
+        console.log(chalk.dim("  Usage: stk brain [push|pull|sync|stats]"));
+        return;
+    }
+    const spinner = ora(`  ${action === "sync" ? "Syncing" : action === "push" ? "Pushing" : "Pulling"} brain knowledge...`).start();
+    try {
+        let result;
+        if (action === "push")
+            result = await pushToCloud();
+        else if (action === "pull")
+            result = await pullFromCloud();
+        else
+            result = await syncBrain();
+        if (result.errors.length > 0) {
+            spinner.fail(`  Sync completed with errors`);
+            for (const err of result.errors) {
+                console.log(`  ${chalk.red("✗")} ${err}`);
+            }
+            console.log();
+            return;
+        }
+        spinner.succeed(`  Brain ${action} complete`);
+        console.log();
+        if (result.pushed > 0) {
+            console.log(`  ${chalk.green("↑")} Pushed ${chalk.white(result.pushed)} entries to cloud`);
+        }
+        if (result.pulled > 0) {
+            console.log(`  ${chalk.green("↓")} Pulled ${chalk.white(result.pulled)} entries from cloud`);
+        }
+        if (result.pushed === 0 && result.pulled === 0) {
+            console.log(chalk.dim("  Everything is in sync."));
+        }
+        console.log();
+    }
+    catch (err) {
+        spinner.fail("  Sync failed");
+        console.log(`  ${chalk.red(err instanceof Error ? err.message : String(err))}`);
+        console.log();
+    }
+});

package/dist/commands/ingest.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const ingestCommand: Command;

package/dist/commands/ingest.js

@@ -0,0 +1,81 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { ingestProject, loadBrainStore, saveBrainStore } from "../services/brain.js";
+export const ingestCommand = new Command("ingest")
+    .description("Scan project and ingest architecture knowledge into the local brain")
+    .option("--force", "re-ingest even if already ingested")
+    .option("--stats", "show what's been ingested across all projects")
+    .action(async (opts) => {
+    if (opts.stats) {
+        const store = loadBrainStore();
+        const projects = Object.entries(store.projects);
+        console.log();
+        console.log(chalk.bold("  Brain Stats"));
+        console.log(chalk.dim("  ─────────────────────────────────────────"));
+        console.log(`  Global entries:  ${chalk.white(store.global.length)}`);
+        console.log(`  Projects:        ${chalk.white(projects.length)}`);
+        console.log();
+        for (const [name, proj] of projects) {
+            console.log(`  ${chalk.green("●")} ${chalk.bold(name)}`);
+            console.log(`    Entries:    ${proj.entries.length}`);
+            console.log(`    Ingested:   ${proj.ingestedAt}`);
+            console.log(`    Path:       ${chalk.dim(proj.projectPath)}`);
+            const categories = {};
+            for (const e of proj.entries) {
+                categories[e.category] = (categories[e.category] || 0) + 1;
+            }
+            console.log(`    Categories: ${Object.entries(categories).map(([k, v]) => `${k}(${v})`).join(", ")}`);
+            console.log();
+        }
+        if (projects.length === 0) {
+            console.log(chalk.dim("  No projects ingested yet. Run: stk ingest"));
+            console.log();
+        }
+        return;
+    }
+    const projectPath = process.cwd();
+    const store = loadBrainStore();
+    // Check if already ingested
+    const { projectName, entries, filesScanned } = ingestProject(projectPath);
+    if (store.projects[projectName] && !opts.force) {
+        const existing = store.projects[projectName];
+        console.log();
+        console.log(chalk.yellow(`  "${projectName}" already ingested (${existing.entries.length} entries, ${existing.ingestedAt})`));
+        console.log(chalk.dim("  Use --force to re-ingest."));
+        console.log();
+        return;
+    }
+    if (entries.length === 0) {
+        console.log();
+        console.log(chalk.yellow("  No knowledge extracted. Make sure you're in a project directory."));
+        console.log();
+        return;
+    }
+    // Save
+    store.projects[projectName] = {
+        ingestedAt: new Date().toISOString(),
+        projectPath,
+        entries,
+    };
+    saveBrainStore(store);
+    console.log();
+    console.log(`  ${chalk.green("✓")} Ingested ${chalk.bold(projectName)} — ${chalk.white(entries.length)} knowledge entries`);
+    console.log();
+    console.log(chalk.bold("  Files scanned:"));
+    for (const file of filesScanned) {
+        console.log(`  ${chalk.green("●")} ${file}`);
+    }
+    console.log();
+    const categories = {};
+    for (const e of entries) {
+        categories[e.category] = (categories[e.category] || 0) + 1;
+    }
+    console.log(chalk.bold("  Knowledge by category:"));
+    for (const [cat, count] of Object.entries(categories).sort(([, a], [, b]) => b - a)) {
+        console.log(`  ${chalk.dim("●")} ${cat}: ${count}`);
+    }
+    console.log();
+    console.log(chalk.dim(`  Stored at: ~/.stk/brain.json`));
+    console.log(chalk.dim(`  Brain tools (stk_brain_search, stk_brain_learn, etc.) now work locally.`));
+    console.log();
+});

package/dist/index.js

@@ -8,6 +8,8 @@ import { envCommand } from "./commands/env.js";
 import { logsCommand } from "./commands/logs.js";
 import { todoCommand } from "./commands/todo.js";
 import { doctorCommand } from "./commands/doctor.js";
+import { ingestCommand } from "./commands/ingest.js";
+import { brainCommand } from "./commands/brain.js";
 const program = new Command();
 program
     .name("stk")
@@ -21,4 +23,6 @@ program.addCommand(envCommand);
 program.addCommand(logsCommand);
 program.addCommand(todoCommand);
 program.addCommand(doctorCommand);
+program.addCommand(ingestCommand);
+program.addCommand(brainCommand);
 program.parse();

package/dist/mcp/server.js

@@ -11,6 +11,7 @@ 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 { execSync } from "child_process";
 const server = new McpServer({
     name: "stk",
@@ -1012,40 +1013,7 @@ server.tool("stk_cost", "Track costs across your stack: Stripe fees, Vercel usag
 // Brain: Supabase Knowledge Base Client
 // ──────────────────────────────────────────
 function getBrainClient() {
-    const url = process.env.SUPABASE_URL;
-    const key = process.env.SUPABASE_SERVICE_KEY;
-    if (!url || !key)
-        return null;
-    return {
-        async query(table, params = {}) {
-            const searchParams = new URLSearchParams(params);
-            const res = await fetch(`${url}/rest/v1/${table}?${searchParams}`, {
-                headers: {
-                    apikey: key,
-                    Authorization: `Bearer ${key}`,
-                    "Content-Type": "application/json",
-                    Prefer: "count=exact",
-                },
-            });
-            const count = res.headers.get("content-range")?.split("/")[1] ?? null;
-            const data = await res.json();
-            return { data, count, ok: res.ok };
-        },
-        async insert(table, row) {
-            const res = await fetch(`${url}/rest/v1/${table}`, {
-                method: "POST",
-                headers: {
-                    apikey: key,
-                    Authorization: `Bearer ${key}`,
-                    "Content-Type": "application/json",
-                    Prefer: "return=representation",
-                },
-                body: JSON.stringify(row),
-            });
-            const data = await res.json();
-            return { data, ok: res.ok };
-        },
-    };
+    return getLocalBrainClient();
 }
 // ──────────────────────────────────────────
 // Tool: stk_brain_search
@@ -1055,8 +1023,6 @@ server.tool("stk_brain_search", "Search the knowledge base for SaaS patterns, be
     category: z.string().optional().describe("Filter: architecture, auth, payments, database, api, deployment, testing, performance, security, ml, realtime, general"),
 }, async ({ query, category }) => {
     const brain = getBrainClient();
-    if (!brain)
-        return { content: [{ type: "text", text: JSON.stringify({ error: "SUPABASE_URL or SUPABASE_SERVICE_KEY not set" }) }] };
     // Try ilike search on content and title
     const words = query.split(" ").filter(w => w.length > 2);
     const searchWord = words[0] ?? query;
@@ -1088,8 +1054,6 @@ server.tool("stk_brain_patterns", "Get best practice patterns for a specific fea
     feature: z.string().describe("The feature or pattern (e.g., 'authentication', 'webhooks', 'caching', 'model serving', 'fine-tuning')"),
 }, async ({ feature }) => {
     const brain = getBrainClient();
-    if (!brain)
-        return { content: [{ type: "text", text: JSON.stringify({ error: "SUPABASE_URL or SUPABASE_SERVICE_KEY not set" }) }] };
     const { data, ok } = await brain.query("knowledge", {
         or: `(title.ilike.%${feature}%,content.ilike.%${feature}%)`,
         limit: "15",
@@ -1123,8 +1087,6 @@ server.tool("stk_brain_stack", "Get recommendations specific to YOUR stack (Supa
     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();
-    if (!brain)
-        return { content: [{ type: "text", text: JSON.stringify({ error: "SUPABASE_URL or SUPABASE_SERVICE_KEY not set" }) }] };
     const words = question.split(" ").filter(w => w.length > 3);
     const searchWord = words[0] ?? question;
     const { data, ok } = await brain.query("knowledge", {
@@ -1156,8 +1118,6 @@ server.tool("stk_brain_learn", "Save new knowledge to the brain. Use this to rem
     tags: z.array(z.string()).optional().describe("Tags for searchability"),
 }, async ({ title, content, source, category, tags }) => {
     const brain = getBrainClient();
-    if (!brain)
-        return { content: [{ type: "text", text: JSON.stringify({ error: "SUPABASE_URL or SUPABASE_SERVICE_KEY not set" }) }] };
     const { data, ok } = await brain.insert("knowledge", {
         title,
         content,
@@ -1180,8 +1140,6 @@ server.tool("stk_brain_learn", "Save new knowledge to the brain. Use this to rem
 // ──────────────────────────────────────────
 server.tool("stk_brain_stats", "Check what the brain knows — total knowledge entries, categories, sources, and coverage.", {}, async () => {
     const brain = getBrainClient();
-    if (!brain)
-        return { content: [{ type: "text", text: JSON.stringify({ error: "SUPABASE_URL or SUPABASE_SERVICE_KEY not set" }) }] };
     const { data, count } = await brain.query("knowledge", { select: "category,source", limit: "1000" });
     const categories = {};
     const sources = {};
@@ -1205,6 +1163,87 @@ server.tool("stk_brain_stats", "Check what the brain knows — total knowledge e
     };
 });
 // ──────────────────────────────────────────
+// 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_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.", {

package/dist/services/brain.d.ts

@@ -0,0 +1,66 @@
+export interface KnowledgeEntry {
+    id: string;
+    title: string;
+    content: string;
+    category: string;
+    source: string;
+    tags: string[];
+    created_at: string;
+}
+interface ProjectBrain {
+    ingestedAt: string;
+    projectPath: string;
+    entries: KnowledgeEntry[];
+}
+interface BrainStore {
+    version: 1;
+    projects: Record<string, ProjectBrain>;
+    global: KnowledgeEntry[];
+}
+export declare function loadBrainStore(): BrainStore;
+export declare function saveBrainStore(store: BrainStore): void;
+/** Get all entries — optionally scoped to a project */
+export declare function getAllEntries(store: BrainStore, projectName?: string): KnowledgeEntry[];
+/** Extract knowledge from CLAUDE.md sections */
+export declare function extractFromClaudeMd(filePath: string, projectName: string): KnowledgeEntry[];
+/** Extract knowledge from package.json */
+export declare function extractFromPackageJson(filePath: string, projectName: string): KnowledgeEntry[];
+/** Extract knowledge from Prisma schema */
+export declare function extractFromPrismaSchema(filePath: string, projectName: string): KnowledgeEntry[];
+/** Extract knowledge from Dockerfile */
+export declare function extractFromDockerfile(filePath: string, projectName: string): KnowledgeEntry[];
+/** Extract knowledge from CI config */
+export declare function extractFromCIConfig(filePath: string, projectName: string): KnowledgeEntry[];
+/** Extract knowledge from route files directory */
+export declare function extractFromRoutes(routeDir: string, projectName: string): KnowledgeEntry[];
+/** Extract knowledge from stk.config.json */
+export declare function extractFromStkConfig(filePath: string, projectName: string): KnowledgeEntry[];
+interface IngestResult {
+    projectName: string;
+    entries: KnowledgeEntry[];
+    filesScanned: string[];
+}
+export declare function ingestProject(projectPath: string): IngestResult;
+export declare function getLocalBrainClient(): {
+    query(_table: string, params?: Record<string, string>): Promise<{
+        data: KnowledgeEntry[];
+        count: number;
+        ok: boolean;
+    }>;
+    insert(_table: string, row: Record<string, unknown>): Promise<{
+        data: KnowledgeEntry;
+        ok: boolean;
+    }>;
+};
+export interface SyncResult {
+    pushed: number;
+    pulled: number;
+    errors: string[];
+}
+/** Push all local entries to cloud */
+export declare function pushToCloud(): Promise<SyncResult>;
+/** Pull cloud entries to local */
+export declare function pullFromCloud(): Promise<SyncResult>;
+/** Full sync: push local → cloud, then pull cloud → local */
+export declare function syncBrain(): Promise<SyncResult>;
+export {};

package/dist/services/brain.js

@@ -0,0 +1,526 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from "fs";
+import { join, resolve, basename } from "path";
+import { homedir } from "os";
+import { randomUUID } from "crypto";
+import { loadConfig } from "../lib/config.js";
+// ──────────────────────────────────────────
+// Storage
+// ──────────────────────────────────────────
+const STK_DIR = join(homedir(), ".stk");
+const BRAIN_PATH = join(STK_DIR, "brain.json");
+function ensureStkDir() {
+    if (!existsSync(STK_DIR))
+        mkdirSync(STK_DIR, { recursive: true });
+}
+export function loadBrainStore() {
+    ensureStkDir();
+    if (!existsSync(BRAIN_PATH)) {
+        return { version: 1, projects: {}, global: [] };
+    }
+    try {
+        const raw = readFileSync(BRAIN_PATH, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return { version: 1, projects: {}, global: [] };
+    }
+}
+export function saveBrainStore(store) {
+    ensureStkDir();
+    writeFileSync(BRAIN_PATH, JSON.stringify(store, null, 2));
+}
+/** Get all entries — optionally scoped to a project */
+export function getAllEntries(store, projectName) {
+    const entries = [...store.global];
+    if (projectName && store.projects[projectName]) {
+        entries.push(...store.projects[projectName].entries);
+    }
+    else {
+        for (const proj of Object.values(store.projects)) {
+            entries.push(...proj.entries);
+        }
+    }
+    return entries;
+}
+// ──────────────────────────────────────────
+// Extractors
+// ──────────────────────────────────────────
+function makeEntry(title, content, category, source, tags) {
+    return { id: randomUUID(), title, content, category, source, tags, created_at: new Date().toISOString() };
+}
+/** Extract knowledge from CLAUDE.md sections */
+export function extractFromClaudeMd(filePath, projectName) {
+    const raw = readFileSync(filePath, "utf-8");
+    const entries = [];
+    const source = `project:${projectName}`;
+    // Split by ## headings
+    const sections = raw.split(/^## /m).slice(1);
+    const categoryMap = {
+        architecture: "architecture", commands: "deployment", "key paths": "architecture",
+        "code rules": "architecture", "theming": "architecture", "backend patterns": "architecture",
+        "auth": "auth", "permissions": "auth", "frontend patterns": "architecture",
+        "testing": "testing", "environment": "deployment", "cache": "performance",
+        "queue": "architecture", "database": "database", "deploy": "deployment",
+        "data": "database", "api": "api", "route": "api", "security": "security",
+    };
+    for (const section of sections) {
+        const lines = section.split("\n");
+        const heading = lines[0]?.trim() ?? "";
+        const body = lines.slice(1).join("\n").trim();
+        if (!heading || body.length < 20)
+            continue;
+        // Infer category from heading
+        const headingLower = heading.toLowerCase();
+        let category = "general";
+        for (const [keyword, cat] of Object.entries(categoryMap)) {
+            if (headingLower.includes(keyword)) {
+                category = cat;
+                break;
+            }
+        }
+        // Truncate very long sections
+        const truncated = body.length > 2000 ? body.slice(0, 2000) + "\n..." : body;
+        entries.push(makeEntry(heading, truncated, category, source, [heading.toLowerCase().replace(/[^a-z0-9]+/g, "-")]));
+    }
+    return entries;
+}
+/** Extract knowledge from package.json */
+export function extractFromPackageJson(filePath, projectName) {
+    try {
+        const raw = readFileSync(filePath, "utf-8");
+        const pkg = JSON.parse(raw);
+        const source = `project:${projectName}`;
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        const depNames = Object.keys(deps);
+        const groups = {
+            framework: [], orm: [], auth: [], billing: [], testing: [], ui: [], build: [], other: [],
+        };
+        const classify = {
+            react: "framework", next: "framework", express: "framework", fastify: "framework", "vue": "framework", angular: "framework",
+            prisma: "orm", typeorm: "orm", drizzle: "orm", sequelize: "orm", mongoose: "orm",
+            jsonwebtoken: "auth", passport: "auth", "next-auth": "auth", bcrypt: "auth",
+            stripe: "billing", "@stripe/stripe-js": "billing",
+            jest: "testing", vitest: "testing", mocha: "testing", supertest: "testing",
+            tailwindcss: "ui", "@radix-ui": "ui", "framer-motion": "ui", "shadcn": "ui",
+            vite: "build", webpack: "build", esbuild: "build", tsx: "build", typescript: "build",
+        };
+        for (const dep of depNames) {
+            let grouped = false;
+            for (const [key, group] of Object.entries(classify)) {
+                if (dep.includes(key)) {
+                    groups[group].push(dep);
+                    grouped = true;
+                    break;
+                }
+            }
+            if (!grouped)
+                groups.other.push(dep);
+        }
+        const parts = [];
+        if (pkg.name)
+            parts.push(`Package: ${pkg.name}`);
+        if (pkg.scripts)
+            parts.push(`Scripts: ${Object.keys(pkg.scripts).join(", ")}`);
+        for (const [group, deps] of Object.entries(groups)) {
+            if (deps.length > 0 && group !== "other")
+                parts.push(`${group}: ${deps.join(", ")}`);
+        }
+        const label = filePath.includes("node-backend") ? "Backend" :
+            filePath.includes("frontend") ? "Frontend" : "Root";
+        return [makeEntry(`${label} Dependencies & Scripts`, parts.join("\n"), "stack", source, ["dependencies", label.toLowerCase(), ...depNames.slice(0, 10)])];
+    }
+    catch {
+        return [];
+    }
+}
+/** Extract knowledge from Prisma schema */
+export function extractFromPrismaSchema(filePath, projectName) {
+    try {
+        const content = readFileSync(filePath, "utf-8");
+        const source = `project:${projectName}`;
+        const models = content.match(/^model \w+/gm) ?? [];
+        const modelNames = models.map(m => m.replace("model ", ""));
+        const enums = content.match(/^enum \w+/gm) ?? [];
+        const enumNames = enums.map(e => e.replace("enum ", ""));
+        const hasOrgId = content.includes("organizationId");
+        const hasSoftDelete = content.includes("deletedAt");
+        const hasTimestamps = content.includes("@updatedAt");
+        const hasRelations = content.match(/@relation/g)?.length ?? 0;
+        const parts = [
+            `${models.length} models: ${modelNames.join(", ")}`,
+        ];
+        if (enums.length)
+            parts.push(`${enums.length} enums: ${enumNames.join(", ")}`);
+        if (hasOrgId)
+            parts.push("Multi-tenant: organizationId on entities");
+        if (hasSoftDelete)
+            parts.push("Soft deletes: deletedAt field");
+        if (hasTimestamps)
+            parts.push("Auto timestamps: createdAt/updatedAt");
+        if (hasRelations)
+            parts.push(`${hasRelations} relations defined`);
+        return [makeEntry("Database Schema Overview", parts.join("\n"), "database", source, ["prisma", "schema", "database", ...modelNames.slice(0, 15)])];
+    }
+    catch {
+        return [];
+    }
+}
+/** Extract knowledge from Dockerfile */
+export function extractFromDockerfile(filePath, projectName) {
+    try {
+        const content = readFileSync(filePath, "utf-8");
+        const source = `project:${projectName}`;
+        const parts = [];
+        const baseImages = content.match(/^FROM\s+\S+/gm) ?? [];
+        if (baseImages.length)
+            parts.push(`Base images: ${baseImages.map(b => b.replace("FROM ", "")).join(" → ")}`);
+        if (baseImages.length > 1)
+            parts.push("Multi-stage build");
+        if (content.includes("HEALTHCHECK"))
+            parts.push("Has healthcheck");
+        if (content.includes("USER") && !content.includes("USER root"))
+            parts.push("Non-root user");
+        if (content.includes("tini"))
+            parts.push("Uses tini init");
+        const ports = content.match(/EXPOSE\s+(\d+)/g);
+        if (ports)
+            parts.push(`Ports: ${ports.map(p => p.replace("EXPOSE ", "")).join(", ")}`);
+        return parts.length > 0
+            ? [makeEntry("Docker Configuration", parts.join("\n"), "deployment", source, ["docker", "container"])]
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Extract knowledge from CI config */
+export function extractFromCIConfig(filePath, projectName) {
+    try {
+        const content = readFileSync(filePath, "utf-8");
+        const source = `project:${projectName}`;
+        const parts = [];
+        if (filePath.includes(".github"))
+            parts.push("CI: GitHub Actions");
+        else if (filePath.includes(".gitlab"))
+            parts.push("CI: GitLab CI");
+        else if (filePath.includes("circle"))
+            parts.push("CI: CircleCI");
+        const jobs = content.match(/^\s{2}\w[\w-]*:/gm);
+        if (jobs)
+            parts.push(`Jobs: ${jobs.map(j => j.trim().replace(":", "")).join(", ")}`);
+        if (content.includes("tsc"))
+            parts.push("Type checking step");
+        if (content.includes("test"))
+            parts.push("Test step");
+        if (content.includes("docker"))
+            parts.push("Docker build step");
+        if (content.includes("audit"))
+            parts.push("Security audit step");
+        const triggers = content.match(/on:\s*\n([\s\S]*?)(?=\n\w)/);
+        if (triggers) {
+            if (content.includes("push:"))
+                parts.push("Triggers on push");
+            if (content.includes("pull_request:"))
+                parts.push("Triggers on PR");
+        }
+        return parts.length > 0
+            ? [makeEntry("CI/CD Pipeline", parts.join("\n"), "deployment", source, ["ci", "pipeline"])]
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Extract knowledge from route files directory */
+export function extractFromRoutes(routeDir, projectName) {
+    try {
+        const source = `project:${projectName}`;
+        const files = readdirSync(routeDir).filter(f => f.endsWith(".ts") || f.endsWith(".js"));
+        const routeNames = files.map(f => f.replace(/\.(ts|js)$/, ""));
+        return [makeEntry("API Routes", `${files.length} route files: ${routeNames.join(", ")}`, "api", source, ["routes", "api", ...routeNames.slice(0, 15)])];
+    }
+    catch {
+        return [];
+    }
+}
+/** Extract knowledge from stk.config.json */
+export function extractFromStkConfig(filePath, projectName) {
+    try {
+        const raw = readFileSync(filePath, "utf-8");
+        const config = JSON.parse(raw);
+        const source = `project:${projectName}`;
+        const services = Object.entries(config.services ?? {})
+            .filter(([, v]) => v === true || (typeof v === "object" && v.enabled !== false))
+            .map(([k]) => k);
+        return services.length > 0
+            ? [makeEntry("Infrastructure Services", `Configured services: ${services.join(", ")}`, "architecture", source, ["infrastructure", ...services])]
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function ingestProject(projectPath) {
+    const config = loadConfig();
+    const projectName = config.name ?? basename(projectPath);
+    const entries = [];
+    const filesScanned = [];
+    const fileExtractors = [
+        { path: "CLAUDE.md", extractor: extractFromClaudeMd },
+        { path: "package.json", extractor: extractFromPackageJson },
+        { path: "node-backend/package.json", extractor: extractFromPackageJson },
+        { path: "frontend/package.json", extractor: extractFromPackageJson },
+        { path: "node-backend/prisma/schema.prisma", extractor: extractFromPrismaSchema },
+        { path: "Dockerfile", extractor: extractFromDockerfile },
+        { path: ".github/workflows/ci.yml", extractor: extractFromCIConfig },
+        { path: "stk.config.json", extractor: extractFromStkConfig },
+    ];
+    // Also try common alternative locations
+    const altPaths = [
+        { path: "prisma/schema.prisma", extractor: extractFromPrismaSchema },
+        { path: "src/prisma/schema.prisma", extractor: extractFromPrismaSchema },
+        { path: ".github/workflows/main.yml", extractor: extractFromCIConfig },
+        { path: ".github/workflows/deploy.yml", extractor: extractFromCIConfig },
+        { path: ".gitlab-ci.yml", extractor: extractFromCIConfig },
+        { path: "docker-compose.yml", extractor: extractFromDockerfile },
+        { path: "backend/package.json", extractor: extractFromPackageJson },
+        { path: "server/package.json", extractor: extractFromPackageJson },
+        { path: "api/package.json", extractor: extractFromPackageJson },
+    ];
+    const allPaths = [...fileExtractors, ...altPaths];
+    const seen = new Set();
+    for (const { path, extractor } of allPaths) {
+        const fullPath = resolve(projectPath, path);
+        if (seen.has(fullPath) || !existsSync(fullPath))
+            continue;
+        seen.add(fullPath);
+        const extracted = extractor(fullPath, projectName);
+        if (extracted.length > 0) {
+            entries.push(...extracted);
+            filesScanned.push(path);
+        }
+    }
+    // Route directories
+    const routeDirs = [
+        "node-backend/src/routes",
+        "src/routes",
+        "backend/src/routes",
+        "server/src/routes",
+        "api/src/routes",
+    ];
+    for (const dir of routeDirs) {
+        const fullDir = resolve(projectPath, dir);
+        if (existsSync(fullDir)) {
+            entries.push(...extractFromRoutes(fullDir, projectName));
+            filesScanned.push(dir);
+            break; // only one route dir
+        }
+    }
+    return { projectName, entries, filesScanned };
+}
+// ──────────────────────────────────────────
+// Local brain client (replaces getBrainClient)
+// ──────────────────────────────────────────
+export function getLocalBrainClient() {
+    const store = loadBrainStore();
+    const config = loadConfig();
+    const projectName = config.name;
+    // Auto-ingest if this project hasn't been scanned yet
+    if (projectName && projectName !== "my-app" && !store.projects[projectName]) {
+        try {
+            const { entries, filesScanned } = ingestProject(process.cwd());
+            if (entries.length > 0) {
+                store.projects[projectName] = {
+                    ingestedAt: new Date().toISOString(),
+                    projectPath: process.cwd(),
+                    entries,
+                };
+                saveBrainStore(store);
+            }
+        }
+        catch {
+            // Ingest failure shouldn't block brain tools
+        }
+    }
+    return {
+        async query(_table, params = {}) {
+            const currentStore = loadBrainStore();
+            let entries = getAllEntries(currentStore);
+            // Handle ilike search (Supabase PostgREST style)
+            if (params.or) {
+                const matches = params.or.match(/ilike\.%(.+?)%/g);
+                if (matches) {
+                    const searchTerms = matches.map(m => m.replace("ilike.%", "").replace("%", "").toLowerCase());
+                    entries = entries.filter(e => searchTerms.some(term => e.title.toLowerCase().includes(term) ||
+                        e.content.toLowerCase().includes(term) ||
+                        e.tags.some(t => t.toLowerCase().includes(term))));
+                }
+            }
+            // Handle category filter
+            if (params.category) {
+                const cat = params.category.replace("eq.", "");
+                entries = entries.filter(e => e.category === cat);
+            }
+            // Handle select (for stats — just return all fields)
+            // Handle order (best-effort)
+            if (params.order) {
+                const field = params.order;
+                entries.sort((a, b) => String(a[field] ?? "").localeCompare(String(b[field] ?? "")));
+            }
+            const limit = parseInt(params.limit ?? "10");
+            const data = entries.slice(0, limit);
+            return { data, count: entries.length, ok: true };
+        },
+        async insert(_table, row) {
+            const currentStore = loadBrainStore();
+            const entry = {
+                id: randomUUID(),
+                title: String(row.title ?? ""),
+                content: String(row.content ?? ""),
+                category: String(row.category ?? "general"),
+                source: String(row.source ?? "manual"),
+                tags: Array.isArray(row.tags) ? row.tags.map(String) : [],
+                created_at: String(row.created_at ?? new Date().toISOString()),
+            };
+            currentStore.global.push(entry);
+            saveBrainStore(currentStore);
+            // Also push to cloud if configured
+            try {
+                await cloudInsert(entry);
+            }
+            catch { /* cloud sync is best-effort */ }
+            return { data: entry, ok: true };
+        },
+    };
+}
+// ──────────────────────────────────────────
+// Cloud sync (Supabase-backed)
+// ──────────────────────────────────────────
+function getCloudConfig() {
+    const url = process.env.SUPABASE_URL;
+    const key = process.env.SUPABASE_SERVICE_KEY;
+    if (!url || !key)
+        return null;
+    return { url, key };
+}
+async function cloudInsert(entry) {
+    const cloud = getCloudConfig();
+    if (!cloud)
+        return false;
+    const res = await fetch(`${cloud.url}/rest/v1/knowledge`, {
+        method: "POST",
+        headers: {
+            apikey: cloud.key,
+            Authorization: `Bearer ${cloud.key}`,
+            "Content-Type": "application/json",
+            Prefer: "resolution=ignore-duplicates",
+        },
+        body: JSON.stringify({
+            id: entry.id,
+            title: entry.title,
+            content: entry.content,
+            category: entry.category,
+            source: entry.source,
+            tags: entry.tags,
+            created_at: entry.created_at,
+        }),
+    });
+    return res.ok;
+}
+/** Push all local entries to cloud */
+export async function pushToCloud() {
+    const cloud = getCloudConfig();
+    if (!cloud)
+        return { pushed: 0, pulled: 0, errors: ["SUPABASE_URL or SUPABASE_SERVICE_KEY not set"] };
+    const store = loadBrainStore();
+    const allLocal = getAllEntries(store);
+    let pushed = 0;
+    const errors = [];
+    // Get existing cloud IDs to avoid duplicates
+    const existingRes = await fetch(`${cloud.url}/rest/v1/knowledge?select=id&limit=10000`, {
+        headers: { apikey: cloud.key, Authorization: `Bearer ${cloud.key}` },
+    });
+    const existingData = existingRes.ok ? await existingRes.json() : [];
+    const existingIds = new Set(existingData.map((r) => r.id));
+    // Push entries that don't exist in cloud
+    const toInsert = allLocal.filter(e => !existingIds.has(e.id));
+    // Batch insert in chunks of 50
+    for (let i = 0; i < toInsert.length; i += 50) {
+        const batch = toInsert.slice(i, i + 50);
+        const res = await fetch(`${cloud.url}/rest/v1/knowledge`, {
+            method: "POST",
+            headers: {
+                apikey: cloud.key,
+                Authorization: `Bearer ${cloud.key}`,
+                "Content-Type": "application/json",
+                Prefer: "resolution=ignore-duplicates",
+            },
+            body: JSON.stringify(batch),
+        });
+        if (res.ok) {
+            pushed += batch.length;
+        }
+        else {
+            const err = await res.text();
+            errors.push(`Batch insert failed: ${err}`);
+        }
+    }
+    return { pushed, pulled: 0, errors };
+}
+/** Pull cloud entries to local */
+export async function pullFromCloud() {
+    const cloud = getCloudConfig();
+    if (!cloud)
+        return { pushed: 0, pulled: 0, errors: ["SUPABASE_URL or SUPABASE_SERVICE_KEY not set"] };
+    const store = loadBrainStore();
+    const localIds = new Set(getAllEntries(store).map(e => e.id));
+    let pulled = 0;
+    const errors = [];
+    // Fetch all cloud entries
+    const res = await fetch(`${cloud.url}/rest/v1/knowledge?select=*&limit=10000&order=created_at.desc`, {
+        headers: {
+            apikey: cloud.key,
+            Authorization: `Bearer ${cloud.key}`,
+            "Content-Type": "application/json",
+        },
+    });
+    if (!res.ok) {
+        const err = await res.text();
+        return { pushed: 0, pulled: 0, errors: [`Cloud fetch failed: ${err}`] };
+    }
+    const cloudEntries = await res.json();
+    for (const entry of cloudEntries) {
+        if (localIds.has(entry.id))
+            continue;
+        // Determine where to put it — if source matches a project, add to that project
+        const projectMatch = entry.source.match(/^project:(.+)$/);
+        if (projectMatch) {
+            const projName = projectMatch[1];
+            if (!store.projects[projName]) {
+                store.projects[projName] = {
+                    ingestedAt: entry.created_at,
+                    projectPath: "",
+                    entries: [],
+                };
+            }
+            store.projects[projName].entries.push(entry);
+        }
+        else {
+            store.global.push(entry);
+        }
+        pulled++;
+    }
+    if (pulled > 0)
+        saveBrainStore(store);
+    return { pushed: 0, pulled, errors };
+}
+/** Full sync: push local → cloud, then pull cloud → local */
+export async function syncBrain() {
+    const pushResult = await pushToCloud();
+    const pullResult = await pullFromCloud();
+    return {
+        pushed: pushResult.pushed,
+        pulled: pullResult.pulled,
+        errors: [...pushResult.errors, ...pullResult.errors],
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prajwolkc/stk",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "One CLI to deploy, monitor, debug, and learn about your entire stack. Infrastructure monitoring, knowledge base brain, deploy watching, and GitHub issues — all from one command.",
   "type": "module",
   "license": "MIT",