@prajwolkc/stk 0.6.1 → 0.7.1

package/dist/services/brain.js

@@ -1,326 +1,24 @@
-import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from "fs";
-import { join, resolve, basename } from "path";
-import { homedir } from "os";
+/**
+ * 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
+ */
 import { randomUUID } from "crypto";
 import { loadConfig } from "../lib/config.js";
+export { loadBrainStore, saveBrainStore, getAllEntries } from "./brain-store.js";
+export { extractFromClaudeMd, extractFromPackageJson, extractFromPrismaSchema, extractFromDockerfile, extractFromCIConfig, extractFromRoutes, extractFromStkConfig, ingestProject } from "./brain-extract.js";
+export { smartSearch, extractTerms, brainCheck, brainDiagnose, seedBrain, reviewDiff, getContributor } from "./brain-search.js";
+export { pushToCloud, pullFromCloud, syncBrain, cloudInsert } from "./brain-cloud.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)
+// Local brain client (stays here as the MCP interface)
 // ──────────────────────────────────────────
+import { loadBrainStore, saveBrainStore, getAllEntries } from "./brain-store.js";
+import { ingestProject } from "./brain-extract.js";
+import { cloudInsert } from "./brain-cloud.js";
 export function getLocalBrainClient() {
     const store = loadBrainStore();
     const config = loadConfig();
@@ -328,7 +26,7 @@ export function getLocalBrainClient() {
     // 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());
+            const { entries } = ingestProject(process.cwd());
             if (entries.length > 0) {
                 store.projects[projectName] = {
                     ingestedAt: new Date().toISOString(),
@@ -346,7 +44,6 @@ export function getLocalBrainClient() {
         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) {
@@ -356,13 +53,10 @@ export function getLocalBrainClient() {
                         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] ?? "")));
@@ -393,221 +87,3 @@ export function getLocalBrainClient() {
         },
     };
 }
-// ──────────────────────────────────────────
-// 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],
-    };
-}
-/** 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);
-                // Title match scores higher
-                if (entry.title.toLowerCase().includes(term))
-                    score += 3;
-                // Tag match scores high
-                else if (entry.tags.some(t => t.toLowerCase().includes(term)))
-                    score += 2;
-                // Content match
-                else
-                    score += 1;
-            }
-        }
-        // Boost gotcha/debugging entries
-        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));
-    // Also extract multi-word phrases
-    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);
-    // Add error-specific terms
-    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);
-}

package/dist/services/metrics.d.ts

@@ -0,0 +1,35 @@
+export interface MetricEntry {
+    timestamp: string;
+    type: "deploy" | "health_check" | "error" | "response_time";
+    value: number;
+    metadata: Record<string, string>;
+}
+interface MetricsStore {
+    version: 1;
+    entries: MetricEntry[];
+}
+export declare function loadMetrics(): MetricsStore;
+export declare function saveMetrics(store: MetricsStore): void;
+export declare function recordMetric(type: MetricEntry["type"], value: number, metadata?: Record<string, string>): void;
+export declare function getMetrics(type?: MetricEntry["type"], days?: number, limit?: number): MetricEntry[];
+export declare function getBaseline(type: MetricEntry["type"]): number;
+export declare function compareToBaseline(type: MetricEntry["type"]): {
+    current: number;
+    baseline: number;
+    changePct: number;
+    status: "degraded" | "stable" | "improved";
+};
+export declare function getDeployFrequency(days?: number): {
+    total: number;
+    perDay: number;
+};
+export declare function getErrorRate(days?: number): {
+    total: number;
+    perDay: number;
+};
+export declare function getUptime(days?: number): {
+    checks: number;
+    healthy: number;
+    pct: number;
+};
+export {};