@prajwolkc/stk 0.6.1 → 0.7.1

package/dist/mcp/tools/ops.js

@@ -0,0 +1,411 @@
+import { z } from "zod";
+import { loadConfig, enabledServices } from "../../lib/config.js";
+import { brainDiagnose } from "../../services/brain.js";
+import { execSync } from "child_process";
+export function registerOpsTools(server) {
+    // ──────────────────────────────────────────
+    // Tool: stk_logs
+    // ──────────────────────────────────────────
+    server.tool("stk_logs", "Fetch recent production logs from Railway, Vercel, or other deploy providers. Useful for diagnosing errors and understanding runtime behavior.", {
+        provider: z.enum(["railway", "vercel"]).optional().describe("Which provider to fetch logs from (auto-detects if omitted)"),
+        lines: z.number().optional().default(30).describe("Number of log lines to fetch"),
+    }, async ({ provider, lines }) => {
+        // Railway logs
+        if ((provider === "railway" || !provider) && process.env.RAILWAY_API_TOKEN) {
+            const token = process.env.RAILWAY_API_TOKEN;
+            const projectId = process.env.RAILWAY_PROJECT_ID;
+            const serviceId = process.env.RAILWAY_SERVICE_ID;
+            if (!projectId) {
+                return { content: [{ type: "text", text: JSON.stringify({ error: "RAILWAY_PROJECT_ID not set" }) }] };
+            }
+            // Get latest deployment
+            const serviceFilter = serviceId ? `serviceId: "${serviceId}",` : "";
+            const depRes = await fetch("https://backboard.railway.com/graphql/v2", {
+                method: "POST",
+                headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    query: `{ deployments(first: 1, input: { projectId: "${projectId}", ${serviceFilter} }) { edges { node { id } } } }`,
+                }),
+            });
+            const depData = (await depRes.json());
+            const deploymentId = depData.data?.deployments?.edges?.[0]?.node?.id;
+            if (!deploymentId) {
+                return { content: [{ type: "text", text: JSON.stringify({ error: "No deployments found" }) }] };
+            }
+            const logRes = await fetch("https://backboard.railway.com/graphql/v2", {
+                method: "POST",
+                headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    query: `{ deploymentLogs(deploymentId: "${deploymentId}", limit: ${lines}) { timestamp message severity } }`,
+                }),
+            });
+            const logData = (await logRes.json());
+            const logs = logData.data?.deploymentLogs ?? [];
+            return {
+                content: [{ type: "text", text: JSON.stringify({ provider: "railway", deploymentId, logs }, null, 2) }],
+            };
+        }
+        // Vercel logs
+        if ((provider === "vercel" || !provider) && process.env.VERCEL_TOKEN) {
+            const token = process.env.VERCEL_TOKEN;
+            const depRes = await fetch("https://api.vercel.com/v6/deployments?limit=1", {
+                headers: { Authorization: `Bearer ${token}` },
+            });
+            const depData = (await depRes.json());
+            const dep = depData.deployments?.[0];
+            if (!dep) {
+                return { content: [{ type: "text", text: JSON.stringify({ error: "No deployments found" }) }] };
+            }
+            const logRes = await fetch(`https://api.vercel.com/v2/deployments/${dep.uid}/events`, {
+                headers: { Authorization: `Bearer ${token}` },
+            });
+            const events = (await logRes.json());
+            const logs = Array.isArray(events)
+                ? events
+                    .filter((e) => e.type === "stdout" || e.type === "stderr")
+                    .slice(-lines)
+                    .map((e) => ({
+                    timestamp: new Date(e.created).toISOString(),
+                    message: e.payload?.text ?? e.text ?? "",
+                    severity: e.type === "stderr" ? "ERROR" : "INFO",
+                }))
+                : [];
+            return {
+                content: [{ type: "text", text: JSON.stringify({ provider: "vercel", deploymentUrl: dep.url, logs }, null, 2) }],
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify({ error: "No log provider available. Set RAILWAY_API_TOKEN or VERCEL_TOKEN." }) }],
+        };
+    });
+    // ──────────────────────────────────────────
+    // Tool: stk_deploy
+    // ──────────────────────────────────────────
+    server.tool("stk_deploy", "Push current branch to remote and trigger deploys. Use with caution — this pushes code to production.", {
+        skipPush: z.boolean().optional().describe("Skip git push, just report current deploy status"),
+    }, async ({ skipPush }) => {
+        const config = loadConfig();
+        const branch = config.deploy?.branch ?? "main";
+        if (!skipPush) {
+            try {
+                const currentBranch = execSync("git rev-parse --abbrev-ref HEAD", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+                if (currentBranch !== branch) {
+                    return {
+                        content: [{ type: "text", text: JSON.stringify({ error: `On branch "${currentBranch}", not "${branch}". Switch branches first.` }) }],
+                    };
+                }
+                execSync(`git push origin ${branch}`, { encoding: "utf-8", stdio: "pipe" });
+            }
+            catch (err) {
+                return {
+                    content: [{ type: "text", text: JSON.stringify({ error: `Git push failed: ${err instanceof Error ? err.message : String(err)}` }) }],
+                };
+            }
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        pushed: !skipPush,
+                        branch,
+                        providers: config.deploy?.providers ?? [],
+                        note: "Deploy triggered. Use stk_health to verify after a few minutes.",
+                    }, null, 2),
+                }],
+        };
+    });
+    // ──────────────────────────────────────────
+    // Tool: stk_rollback
+    // ──────────────────────────────────────────
+    server.tool("stk_rollback", "Rollback to a previous Vercel deployment. Lists recent deploys and can promote an older one to production.", {
+        deployId: z.string().optional().describe("Deployment ID to rollback to. If omitted, lists recent deployments to choose from."),
+        confirm: z.boolean().optional().default(false).describe("Must be true to actually execute the rollback"),
+    }, async ({ deployId, confirm }) => {
+        const token = process.env.VERCEL_TOKEN;
+        if (!token) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: "VERCEL_TOKEN not set" }) }] };
+        }
+        // List recent deployments
+        const depRes = await fetch("https://api.vercel.com/v6/deployments?limit=10", {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        const depData = await depRes.json();
+        const deployments = (depData.deployments ?? []).map((d) => ({
+            id: d.uid,
+            url: d.url,
+            state: d.readyState ?? d.state,
+            created: new Date(d.created).toISOString(),
+            target: d.target ?? "preview",
+        }));
+        if (!deployId) {
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            message: "Recent deployments — provide a deployId to rollback",
+                            deployments,
+                        }, null, 2),
+                    }],
+            };
+        }
+        if (!confirm) {
+            const target = deployments.find((d) => d.id === deployId);
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            message: "Rollback requires confirmation. Call again with confirm: true",
+                            target: target ?? deployId,
+                        }, null, 2),
+                    }],
+            };
+        }
+        // Execute rollback by promoting the old deployment
+        try {
+            // Get the deployment's project
+            const detailRes = await fetch(`https://api.vercel.com/v13/deployments/${deployId}`, {
+                headers: { Authorization: `Bearer ${token}` },
+            });
+            const detail = await detailRes.json();
+            const projectId = detail.projectId;
+            if (!projectId) {
+                return { content: [{ type: "text", text: JSON.stringify({ error: "Could not determine project from deployment" }) }] };
+            }
+            // Create a new deployment based on the old one (redeploy)
+            const rollbackRes = await fetch(`https://api.vercel.com/v13/deployments`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    name: detail.name,
+                    deploymentId: deployId,
+                    target: "production",
+                }),
+            });
+            if (!rollbackRes.ok) {
+                const errData = await rollbackRes.json();
+                return { content: [{ type: "text", text: JSON.stringify({ error: errData.error?.message ?? `HTTP ${rollbackRes.status}` }) }] };
+            }
+            const rollbackData = await rollbackRes.json();
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            rolledBack: true,
+                            newDeploymentId: rollbackData.id,
+                            url: rollbackData.url,
+                            note: "Rollback triggered. Use stk_health to verify.",
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) }) }] };
+        }
+    });
+    // ──────────────────────────────────────────
+    // Tool: stk_env_sync
+    // ──────────────────────────────────────────
+    server.tool("stk_env_sync", "Compare and sync environment variables between local .env and Vercel. Shows which vars are missing, extra, or mismatched.", {
+        action: z.enum(["diff", "pull", "push"]).optional().default("diff").describe("diff: compare local vs remote. pull: download remote to .env.pulled. push: upload local to Vercel."),
+        confirm: z.boolean().optional().default(false).describe("Required for push action"),
+    }, async ({ action, confirm }) => {
+        const token = process.env.VERCEL_TOKEN;
+        const projectId = process.env.VERCEL_PROJECT_ID;
+        // Read local .env
+        let localVars = {};
+        try {
+            const { readFileSync } = await import("fs");
+            const envContent = readFileSync(".env", "utf-8");
+            for (const line of envContent.split("\n")) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith("#"))
+                    continue;
+                const eqIdx = trimmed.indexOf("=");
+                if (eqIdx > 0) {
+                    localVars[trimmed.slice(0, eqIdx)] = trimmed.slice(eqIdx + 1);
+                }
+            }
+        }
+        catch {
+            localVars = {};
+        }
+        if (!token) {
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            localVars: Object.keys(localVars),
+                            remote: "VERCEL_TOKEN not set — cannot fetch remote env vars",
+                        }, null, 2),
+                    }],
+            };
+        }
+        // Fetch Vercel env vars
+        let remoteVars = {};
+        const envUrl = projectId
+            ? `https://api.vercel.com/v9/projects/${projectId}/env`
+            : null;
+        if (envUrl) {
+            try {
+                const res = await fetch(envUrl, {
+                    headers: { Authorization: `Bearer ${token}` },
+                });
+                const data = await res.json();
+                for (const env of data.envs ?? []) {
+                    remoteVars[env.key] = env.value ?? "(encrypted)";
+                }
+            }
+            catch { /* skip */ }
+        }
+        const localKeys = new Set(Object.keys(localVars));
+        const remoteKeys = new Set(Object.keys(remoteVars));
+        const onlyLocal = [...localKeys].filter((k) => !remoteKeys.has(k));
+        const onlyRemote = [...remoteKeys].filter((k) => !localKeys.has(k));
+        const shared = [...localKeys].filter((k) => remoteKeys.has(k));
+        if (action === "diff" || !action) {
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            localCount: localKeys.size,
+                            remoteCount: remoteKeys.size,
+                            onlyInLocal: onlyLocal,
+                            onlyInRemote: onlyRemote,
+                            inBoth: shared.length,
+                            note: projectId ? undefined : "Set VERCEL_PROJECT_ID for remote env comparison",
+                        }, null, 2),
+                    }],
+            };
+        }
+        if (action === "pull") {
+            const { writeFileSync } = await import("fs");
+            const lines = Object.entries(remoteVars).map(([k, v]) => `${k}=${v}`);
+            writeFileSync(".env.pulled", lines.join("\n") + "\n");
+            return {
+                content: [{ type: "text", text: JSON.stringify({ pulled: true, file: ".env.pulled", count: lines.length }) }],
+            };
+        }
+        if (action === "push") {
+            if (!confirm) {
+                return {
+                    content: [{ type: "text", text: JSON.stringify({ message: "Push requires confirm: true. This will overwrite remote env vars.", varsToUpload: onlyLocal.length + shared.length }) }],
+                };
+            }
+            if (!projectId || !envUrl) {
+                return { content: [{ type: "text", text: JSON.stringify({ error: "VERCEL_PROJECT_ID required for push" }) }] };
+            }
+            let uploaded = 0;
+            for (const [key, value] of Object.entries(localVars)) {
+                await fetch(envUrl, {
+                    method: "POST",
+                    headers: {
+                        Authorization: `Bearer ${token}`,
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify({
+                        key,
+                        value,
+                        type: "encrypted",
+                        target: ["production", "preview", "development"],
+                    }),
+                });
+                uploaded++;
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify({ pushed: true, uploaded }) }],
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify({ error: "Unknown action" }) }] };
+    });
+    // ──────────────────────────────────────────
+    // Tool: stk_autofix
+    // ──────────────────────────────────────────
+    server.tool("stk_autofix", "Auto-diagnose errors from production logs. Fetches recent logs, extracts errors, and searches the brain for matching solutions. Returns errors with matched fix patterns and confidence scores.", {
+        provider: z.enum(["railway", "vercel"]).optional(),
+        lines: z.number().optional().default(50),
+    }, async ({ provider, lines }) => {
+        // Determine provider
+        const config = loadConfig();
+        const detected = provider ?? (enabledServices(config).includes("railway") ? "railway" : "vercel");
+        // Fetch logs using existing stk_logs logic (inline)
+        let logs = [];
+        try {
+            if (detected === "railway") {
+                const token = process.env.RAILWAY_API_TOKEN;
+                const projectId = process.env.RAILWAY_PROJECT_ID;
+                const serviceId = process.env.RAILWAY_SERVICE_ID;
+                if (token && projectId && serviceId) {
+                    const envId = process.env.RAILWAY_ENVIRONMENT_ID;
+                    const gql = `query { deployments(first:1, input:{projectId:"${projectId}",serviceId:"${serviceId}"${envId ? `,environmentId:"${envId}"` : ""}}) { edges { node { id } } } }`;
+                    const depRes = await fetch("https://backboard.railway.app/graphql/v2", {
+                        method: "POST",
+                        headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+                        body: JSON.stringify({ query: gql }),
+                    });
+                    const depData = await depRes.json();
+                    const depId = (depData?.data?.deployments?.edges?.[0]?.node?.id) ?? null;
+                    if (depId) {
+                        const logGql = `query { deploymentLogs(deploymentId:"${depId}",limit:${lines}) { timestamp message severity } }`;
+                        const logRes = await fetch("https://backboard.railway.app/graphql/v2", {
+                            method: "POST",
+                            headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+                            body: JSON.stringify({ query: logGql }),
+                        });
+                        const logData = await logRes.json();
+                        logs = (logData?.data?.deploymentLogs ?? []);
+                    }
+                }
+            }
+        }
+        catch { /* log fetch failed */ }
+        // Filter for errors
+        const errorPattern = /error|exception|fail|crash|ECONNREFUSED|timeout|TypeError|ReferenceError|rejected|FATAL/i;
+        const errorLogs = logs.filter(l => l.severity === "error" || (l.message && errorPattern.test(l.message)));
+        // Deduplicate by first 100 chars
+        const grouped = new Map();
+        for (const log of errorLogs) {
+            const key = log.message.slice(0, 100);
+            const existing = grouped.get(key);
+            if (existing) {
+                existing.count++;
+                existing.lastSeen = log.timestamp;
+            }
+            else {
+                grouped.set(key, { message: log.message, count: 1, firstSeen: log.timestamp, lastSeen: log.timestamp });
+            }
+        }
+        // Diagnose each unique error
+        const errors = [];
+        let matchedErrors = 0;
+        for (const error of grouped.values()) {
+            const matches = brainDiagnose(error.message);
+            const solutions = matches.slice(0, 3).map(m => ({
+                title: m.entry.title,
+                content: m.entry.content.slice(0, 400),
+                confidence: Math.min(1, m.score / 10),
+                source: m.entry.source,
+            }));
+            if (solutions.length > 0)
+                matchedErrors++;
+            errors.push({ ...error, solutions });
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        provider: detected,
+                        errors,
+                        summary: {
+                            totalErrors: errorLogs.length,
+                            uniqueErrors: grouped.size,
+                            matchedErrors,
+                            unmatchedErrors: grouped.size - matchedErrors,
+                        },
+                    }, null, 2),
+                }],
+        };
+    });
+} // end registerOpsTools

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

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

package/dist/mcp/tools/security.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { runAllChecks } from "../../services/security.js";
+export function registerSecurityTools(server) {
+    // ──────────────────────────────────────────
+    // Tool: stk_secure
+    // ──────────────────────────────────────────
+    server.tool("stk_secure", "Security scan — check for exposed secrets, vulnerable dependencies, missing rate limiting, open CORS, and unprotected routes. Returns findings with severity levels and fix suggestions.", {
+        checks: z.array(z.enum(["secrets", "deps", "rate_limit", "cors", "auth"])).optional().describe("Specific checks to run (default: all)"),
+    }, async ({ checks }) => {
+        const findings = runAllChecks(checks);
+        const critical = findings.filter(f => f.level === "critical").length;
+        const warning = findings.filter(f => f.level === "warning").length;
+        const info = findings.filter(f => f.level === "info").length;
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        findings,
+                        summary: { critical, warning, info, total: findings.length },
+                        status: critical > 0 ? "CRITICAL" : warning > 0 ? "WARNING" : "CLEAN",
+                    }, null, 2),
+                }],
+        };
+    });
+} // end registerSecurityTools

package/dist/mcp/types.d.ts

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

package/dist/mcp/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,13 @@
+import type { KnowledgeEntry } from "./brain-store.js";
+export declare function cloudInsert(entry: KnowledgeEntry): Promise<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>;

package/dist/services/brain-cloud.js

@@ -0,0 +1,131 @@
+import { loadBrainStore, getAllEntries, saveBrainStore } from "./brain-store.js";
+// ──────────────────────────────────────────
+// 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 };
+}
+export 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",
+        },
+        signal: AbortSignal.timeout(15000),
+        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 = [];
+    const existingRes = await fetch(`${cloud.url}/rest/v1/knowledge?select=id&limit=10000`, {
+        headers: { apikey: cloud.key, Authorization: `Bearer ${cloud.key}` },
+        signal: AbortSignal.timeout(15000),
+    });
+    const existingData = existingRes.ok ? await existingRes.json() : [];
+    const existingIds = new Set(existingData.map((r) => r.id));
+    const toInsert = allLocal.filter(e => !existingIds.has(e.id));
+    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",
+            },
+            signal: AbortSignal.timeout(15000),
+            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 = [];
+    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",
+        },
+        signal: AbortSignal.timeout(15000),
+    });
+    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;
+        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/dist/services/brain-extract.d.ts

@@ -0,0 +1,14 @@
+import type { KnowledgeEntry } from "./brain-store.js";
+export declare function extractFromClaudeMd(filePath: string, projectName: string): KnowledgeEntry[];
+export declare function extractFromPackageJson(filePath: string, projectName: string): KnowledgeEntry[];
+export declare function extractFromPrismaSchema(filePath: string, projectName: string): KnowledgeEntry[];
+export declare function extractFromDockerfile(filePath: string, projectName: string): KnowledgeEntry[];
+export declare function extractFromCIConfig(filePath: string, projectName: string): KnowledgeEntry[];
+export declare function extractFromRoutes(routeDir: string, projectName: string): KnowledgeEntry[];
+export declare function extractFromStkConfig(filePath: string, projectName: string): KnowledgeEntry[];
+export interface IngestResult {
+    projectName: string;
+    entries: KnowledgeEntry[];
+    filesScanned: string[];
+}
+export declare function ingestProject(projectPath: string): IngestResult;