@prajwolkc/stk 0.6.1 → 0.7.1

package/dist/services/brain-extract.js

@@ -0,0 +1,253 @@
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { resolve, basename } from "path";
+import { randomUUID } from "crypto";
+import { loadConfig } from "../lib/config.js";
+// ──────────────────────────────────────────
+// Extractors
+// ──────────────────────────────────────────
+function makeEntry(title, content, category, source, tags) {
+    return { id: randomUUID(), title, content, category, source, tags, created_at: new Date().toISOString() };
+}
+export function extractFromClaudeMd(filePath, projectName) {
+    const raw = readFileSync(filePath, "utf-8");
+    const entries = [];
+    const source = `project:${projectName}`;
+    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;
+        const headingLower = heading.toLowerCase();
+        let category = "general";
+        for (const [keyword, cat] of Object.entries(categoryMap)) {
+            if (headingLower.includes(keyword)) {
+                category = cat;
+                break;
+            }
+        }
+        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;
+}
+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 [];
+    }
+}
+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 [];
+    }
+}
+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 [];
+    }
+}
+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 [];
+    }
+}
+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 [];
+    }
+}
+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 },
+    ];
+    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);
+        }
+    }
+    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;
+        }
+    }
+    return { projectName, entries, filesScanned };
+}

package/dist/services/brain-search.d.ts

@@ -0,0 +1,33 @@
+import type { KnowledgeEntry } from "./brain-store.js";
+export 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;

package/dist/services/brain-search.js

@@ -0,0 +1,153 @@
+import { execSync } from "child_process";
+import { loadBrainStore, getAllEntries, saveBrainStore } from "./brain-store.js";
+/** Search brain with relevance scoring — returns entries ranked by how many terms match */
+export function smartSearch(terms, category) {
+    const store = loadBrainStore();
+    let entries = getAllEntries(store);
+    if (category) {
+        entries = entries.filter(e => e.category === category);
+    }
+    const normalizedTerms = terms.map(t => t.toLowerCase());
+    const scored = [];
+    for (const entry of entries) {
+        const searchText = `${entry.title} ${entry.content} ${entry.tags.join(" ")}`.toLowerCase();
+        const matchedTerms = [];
+        let score = 0;
+        for (const term of normalizedTerms) {
+            if (searchText.includes(term)) {
+                matchedTerms.push(term);
+                if (entry.title.toLowerCase().includes(term))
+                    score += 3;
+                else if (entry.tags.some(t => t.toLowerCase().includes(term)))
+                    score += 2;
+                else
+                    score += 1;
+            }
+        }
+        if (entry.tags.some(t => ["gotcha", "debugging", "bug", "fix", "issue"].includes(t))) {
+            score *= 1.5;
+        }
+        if (score > 0) {
+            scored.push({ entry, score, matchedTerms });
+        }
+    }
+    return scored.sort((a, b) => b.score - a.score);
+}
+/** Extract relevant terms from a task description */
+export function extractTerms(description) {
+    const stopWords = new Set([
+        "a", "an", "the", "is", "are", "was", "were", "be", "been", "being",
+        "have", "has", "had", "do", "does", "did", "will", "would", "could",
+        "should", "may", "might", "shall", "can", "need", "must", "to", "of",
+        "in", "for", "on", "with", "at", "by", "from", "as", "into", "about",
+        "like", "through", "after", "before", "between", "under", "above",
+        "and", "but", "or", "not", "no", "so", "if", "then", "than", "too",
+        "very", "just", "also", "how", "what", "when", "where", "why", "which",
+        "that", "this", "these", "those", "it", "its", "i", "we", "you", "they",
+        "me", "us", "my", "our", "your", "add", "implement", "create", "build",
+        "make", "want", "get", "set", "use", "new", "update", "change",
+    ]);
+    const words = description.toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, " ")
+        .split(/\s+/)
+        .filter(w => w.length > 2 && !stopWords.has(w));
+    const phrases = [];
+    const desc = description.toLowerCase();
+    const commonPhrases = [
+        "email verification", "password reset", "auth state", "user select",
+        "prisma select", "react context", "protected route", "refresh token",
+        "rate limit", "soft delete", "multi-tenant", "org scoping",
+        "file upload", "webhook", "cron job", "background job",
+        "api key", "role based", "permission", "middleware",
+    ];
+    for (const phrase of commonPhrases) {
+        if (desc.includes(phrase))
+            phrases.push(phrase);
+    }
+    return [...new Set([...words, ...phrases])];
+}
+/** Proactive check — find gotchas relevant to a task before coding */
+export function brainCheck(taskDescription) {
+    const terms = extractTerms(taskDescription);
+    return smartSearch(terms);
+}
+/** Diagnose an error — find matching patterns from past issues */
+export function brainDiagnose(error) {
+    const terms = extractTerms(error);
+    const errorTerms = error.toLowerCase()
+        .replace(/[^a-z0-9\s]/g, " ")
+        .split(/\s+/)
+        .filter(w => w.length > 3);
+    const allTerms = [...new Set([...terms, ...errorTerms])];
+    return smartSearch(allTerms);
+}
+/** Seed brain with curated patterns (idempotent) */
+export function seedBrain(patterns, force = false) {
+    const store = loadBrainStore();
+    if (force) {
+        store.global = store.global.filter(e => !e.source.startsWith("seed:"));
+    }
+    const existingIds = new Set(getAllEntries(store).map(e => e.id));
+    let added = 0;
+    let skipped = 0;
+    for (const entry of patterns) {
+        if (existingIds.has(entry.id)) {
+            skipped++;
+            continue;
+        }
+        store.global.push(entry);
+        added++;
+    }
+    if (added > 0)
+        saveBrainStore(store);
+    return { added, skipped };
+}
+export function reviewDiff(diff) {
+    const results = [];
+    const fileChunks = diff.split(/^diff --git /m).slice(1);
+    for (const chunk of fileChunks) {
+        const pathMatch = chunk.match(/b\/(.+?)[\s\n]/);
+        if (!pathMatch)
+            continue;
+        const filePath = pathMatch[1];
+        const addedLines = (chunk.match(/^\+[^+]/gm) ?? []).length;
+        const removedLines = (chunk.match(/^-[^-]/gm) ?? []).length;
+        const linesChanged = addedLines + removedLines;
+        const addedContent = (chunk.match(/^\+(.+)$/gm) ?? []).map(l => l.slice(1)).join(" ");
+        const searchText = `${filePath} ${addedContent}`;
+        const terms = extractTerms(searchText);
+        if (filePath.endsWith(".prisma"))
+            terms.push("prisma", "schema", "database");
+        if (filePath.includes("auth"))
+            terms.push("auth", "authentication");
+        if (filePath.includes("route"))
+            terms.push("route", "api", "endpoint");
+        if (filePath.includes("middleware"))
+            terms.push("middleware");
+        if (filePath.includes("docker") || filePath.includes("Dockerfile"))
+            terms.push("docker", "container");
+        const matches = smartSearch([...new Set(terms)]);
+        if (matches.length > 0) {
+            results.push({
+                file: filePath,
+                linesChanged,
+                warnings: matches.slice(0, 3).map(m => ({
+                    title: m.entry.title,
+                    content: m.entry.content.slice(0, 300),
+                    relevance: m.score,
+                    source: m.entry.source,
+                })),
+            });
+        }
+    }
+    return results;
+}
+/** Get contributor name from git config */
+export function getContributor() {
+    try {
+        return execSync("git config user.name", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    }
+    catch {
+        return "unknown";
+    }
+}

package/dist/services/brain-store.d.ts

@@ -0,0 +1,25 @@
+export interface KnowledgeEntry {
+    id: string;
+    title: string;
+    content: string;
+    category: string;
+    source: string;
+    tags: string[];
+    created_at: string;
+    contributor?: string;
+    updated_at?: string;
+}
+export interface ProjectBrain {
+    ingestedAt: string;
+    projectPath: string;
+    entries: KnowledgeEntry[];
+}
+export 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[];

package/dist/services/brain-store.js

@@ -0,0 +1,42 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+// ──────────────────────────────────────────
+// 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;
+}

package/dist/services/brain.d.ts

@@ -1,46 +1,22 @@
-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;
+/**
+ * Brain module — re-exports from split modules.
+ *
+ * Split into:
+ *   brain-store.ts   — Types, storage, persistence
+ *   brain-extract.ts — File extractors, project ingestion
+ *   brain-search.ts  — Smart search, check, diagnose, seed, review
+ *   brain-cloud.ts   — Supabase cloud sync
+ */
+export type { KnowledgeEntry, ProjectBrain, BrainStore } from "./brain-store.js";
+export { loadBrainStore, saveBrainStore, getAllEntries } from "./brain-store.js";
+export { extractFromClaudeMd, extractFromPackageJson, extractFromPrismaSchema, extractFromDockerfile, extractFromCIConfig, extractFromRoutes, extractFromStkConfig, ingestProject } from "./brain-extract.js";
+export type { IngestResult } from "./brain-extract.js";
+export type { ScoredEntry } from "./brain-search.js";
+export { smartSearch, extractTerms, brainCheck, brainDiagnose, seedBrain, reviewDiff, getContributor } from "./brain-search.js";
+export type { ReviewWarning } from "./brain-search.js";
+export type { SyncResult } from "./brain-cloud.js";
+export { pushToCloud, pullFromCloud, syncBrain, cloudInsert } from "./brain-cloud.js";
+import type { KnowledgeEntry } from "./brain-store.js";
 export declare function getLocalBrainClient(): {
     query(_table: string, params?: Record<string, string>): Promise<{
         data: KnowledgeEntry[];
@@ -52,28 +28,3 @@ export declare function getLocalBrainClient(): {
         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>;
-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[];
-export {};