midnight-mcp 0.1.40 → 0.2.1

package/dist/utils/health.js

@@ -1,132 +0,0 @@
-/**
- * Health check utilities for MCP server monitoring
- */
-import { githubClient } from "../pipeline/index.js";
-// Track server start time
-const startTime = Date.now();
-// Get package version
-const VERSION = process.env.npm_package_version || "0.0.3";
-/**
- * Check if GitHub API is accessible
- */
-async function checkGitHubAPI() {
-    const start = Date.now();
-    try {
-        // Try to get rate limit info (lightweight API call)
-        const rateLimit = await githubClient.getRateLimit();
-        const latency = Date.now() - start;
-        if (rateLimit.remaining < 100) {
-            return {
-                status: "warn",
-                message: `Rate limit low: ${rateLimit.remaining}/${rateLimit.limit} remaining`,
-                latency,
-            };
-        }
-        return {
-            status: "pass",
-            message: `Rate limit: ${rateLimit.remaining}/${rateLimit.limit}`,
-            latency,
-        };
-    }
-    catch (error) {
-        return {
-            status: "fail",
-            message: `GitHub API error: ${error instanceof Error ? error.message : String(error)}`,
-            latency: Date.now() - start,
-        };
-    }
-}
-/**
- * Check if ChromaDB is accessible (optional dependency)
- */
-async function checkVectorStore() {
-    try {
-        // Import dynamically to handle optional dependency
-        const { vectorStore } = await import("../db/index.js");
-        // Check if vector store is initialized
-        if (vectorStore) {
-            return {
-                status: "pass",
-                message: "Vector store available",
-            };
-        }
-        return {
-            status: "warn",
-            message: "Vector store not initialized (semantic search unavailable)",
-        };
-    }
-    catch {
-        return {
-            status: "warn",
-            message: "Vector store not configured (semantic search unavailable)",
-        };
-    }
-}
-/**
- * Check memory usage
- */
-function checkMemory() {
-    const usage = process.memoryUsage();
-    const heapUsedMB = Math.round(usage.heapUsed / 1024 / 1024);
-    const heapTotalMB = Math.round(usage.heapTotal / 1024 / 1024);
-    const percentUsed = Math.round((usage.heapUsed / usage.heapTotal) * 100);
-    if (percentUsed > 90) {
-        return {
-            status: "fail",
-            message: `High memory usage: ${heapUsedMB}MB/${heapTotalMB}MB (${percentUsed}%)`,
-        };
-    }
-    if (percentUsed > 75) {
-        return {
-            status: "warn",
-            message: `Elevated memory usage: ${heapUsedMB}MB/${heapTotalMB}MB (${percentUsed}%)`,
-        };
-    }
-    return {
-        status: "pass",
-        message: `Memory: ${heapUsedMB}MB/${heapTotalMB}MB (${percentUsed}%)`,
-    };
-}
-/**
- * Perform a full health check
- */
-export async function getHealthStatus() {
-    const checks = [];
-    // Run all health checks in parallel
-    const [githubCheck, vectorCheck] = await Promise.all([
-        checkGitHubAPI(),
-        checkVectorStore(),
-    ]);
-    const memoryCheck = checkMemory();
-    checks.push({ name: "github_api", ...githubCheck }, { name: "vector_store", ...vectorCheck }, { name: "memory", ...memoryCheck });
-    // Determine overall status
-    const hasFailure = checks.some((c) => c.status === "fail");
-    const hasWarning = checks.some((c) => c.status === "warn");
-    let status = "healthy";
-    if (hasFailure) {
-        status = "unhealthy";
-    }
-    else if (hasWarning) {
-        status = "degraded";
-    }
-    return {
-        status,
-        timestamp: new Date().toISOString(),
-        version: VERSION,
-        uptime: Math.round((Date.now() - startTime) / 1000),
-        checks,
-    };
-}
-/**
- * Get a quick health check (no external calls)
- */
-export function getQuickHealthStatus() {
-    return {
-        status: "healthy",
-        timestamp: new Date().toISOString(),
-        version: VERSION,
-        uptime: Math.round((Date.now() - startTime) / 1000),
-        checks: [{ name: "server", status: "pass" }],
-    };
-}
-//# sourceMappingURL=health.js.map

package/dist/utils/hosted-api.d.ts

@@ -1,67 +0,0 @@
-/**
- * Client for the hosted Midnight MCP API
- * Used when running in hosted mode (default)
- */
-export interface HostedSearchResult {
-    code?: string;
-    content?: string;
-    relevanceScore: number;
-    source: {
-        repository: string;
-        filePath: string;
-        lines?: string;
-        section?: string;
-    };
-    codeType?: string;
-    name?: string;
-    isExported?: boolean;
-}
-export interface HostedSearchResponse {
-    results: HostedSearchResult[];
-    totalResults: number;
-    query: string;
-    category?: string;
-    warnings?: string[];
-    lastIndexed?: string | null;
-}
-export interface HostedSearchFilter {
-    language?: string;
-    repository?: string;
-}
-/**
- * Search Compact code via hosted API
- */
-export declare function searchCompactHosted(query: string, limit?: number): Promise<HostedSearchResponse>;
-/**
- * Search TypeScript code via hosted API
- */
-export declare function searchTypeScriptHosted(query: string, limit?: number, includeTypes?: boolean): Promise<HostedSearchResponse>;
-/**
- * Search documentation via hosted API
- */
-export declare function searchDocsHosted(query: string, limit?: number, category?: string): Promise<HostedSearchResponse>;
-/**
- * Generic search via hosted API
- */
-export declare function searchHosted(query: string, limit?: number, filter?: HostedSearchFilter): Promise<HostedSearchResponse>;
-/**
- * Check if the hosted API is available
- */
-export declare function checkHostedApiHealth(): Promise<{
-    available: boolean;
-    documentsIndexed?: number;
-    error?: string;
-}>;
-/**
- * Get hosted API stats
- */
-export declare function getHostedApiStats(): Promise<{
-    documentsIndexed: number;
-    repositories: number;
-}>;
-/**
- * Track a tool call to the hosted API
- * Fire-and-forget - doesn't block on response
- */
-export declare function trackToolCall(tool: string, success: boolean, durationMs?: number, version?: string): void;
-//# sourceMappingURL=hosted-api.d.ts.map

package/dist/utils/hosted-api.js

@@ -1,119 +0,0 @@
-/**
- * Client for the hosted Midnight MCP API
- * Used when running in hosted mode (default)
- */
-import { config, logger } from "./index.js";
-const API_TIMEOUT = 10000; // 10 seconds
-/**
- * Make a request to the hosted API
- */
-async function apiRequest(endpoint, options = {}) {
-    const url = `${config.hostedApiUrl}${endpoint}`;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), API_TIMEOUT);
-    try {
-        const response = await fetch(url, {
-            ...options,
-            signal: controller.signal,
-            headers: {
-                "Content-Type": "application/json",
-                "User-Agent": "midnight-mcp",
-                ...options.headers,
-            },
-        });
-        if (!response.ok) {
-            const errorData = (await response
-                .json()
-                .catch(() => ({ error: "Unknown error" })));
-            throw new Error(errorData.error || `API error: ${response.status}`);
-        }
-        return (await response.json());
-    }
-    catch (error) {
-        if (error instanceof Error && error.name === "AbortError") {
-            throw new Error("API request timed out. The hosted service may be unavailable.");
-        }
-        throw error;
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-}
-/**
- * Search Compact code via hosted API
- */
-export async function searchCompactHosted(query, limit = 10) {
-    logger.debug("Searching Compact code via hosted API", { query });
-    return apiRequest("/v1/search/compact", {
-        method: "POST",
-        body: JSON.stringify({ query, limit }),
-    });
-}
-/**
- * Search TypeScript code via hosted API
- */
-export async function searchTypeScriptHosted(query, limit = 10, includeTypes = true) {
-    logger.debug("Searching TypeScript code via hosted API", { query });
-    return apiRequest("/v1/search/typescript", {
-        method: "POST",
-        body: JSON.stringify({ query, limit, includeTypes }),
-    });
-}
-/**
- * Search documentation via hosted API
- */
-export async function searchDocsHosted(query, limit = 10, category = "all") {
-    logger.debug("Searching documentation via hosted API", { query });
-    return apiRequest("/v1/search/docs", {
-        method: "POST",
-        body: JSON.stringify({ query, limit, category }),
-    });
-}
-/**
- * Generic search via hosted API
- */
-export async function searchHosted(query, limit = 10, filter) {
-    logger.debug("Searching via hosted API", { query, filter });
-    return apiRequest("/v1/search", {
-        method: "POST",
-        body: JSON.stringify({ query, limit, filter }),
-    });
-}
-/**
- * Check if the hosted API is available
- */
-export async function checkHostedApiHealth() {
-    try {
-        const response = await apiRequest("/health");
-        return {
-            available: response.status === "healthy",
-            documentsIndexed: response.vectorStore?.documentsIndexed,
-        };
-    }
-    catch (error) {
-        return {
-            available: false,
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-/**
- * Get hosted API stats
- */
-export async function getHostedApiStats() {
-    return apiRequest("/v1/stats");
-}
-/**
- * Track a tool call to the hosted API
- * Fire-and-forget - doesn't block on response
- */
-export function trackToolCall(tool, success, durationMs, version) {
-    // Fire and forget - don't await, don't block
-    apiRequest("/v1/track/tool", {
-        method: "POST",
-        body: JSON.stringify({ tool, success, durationMs, version }),
-    }).catch(() => {
-        // Silently ignore tracking errors
-    });
-}
-//# sourceMappingURL=hosted-api.js.map

package/dist/utils/index.d.ts

@@ -1,16 +0,0 @@
-export { config, isHostedMode, isLocalMode } from "./config.js";
-export type { Config, RepositoryConfig } from "./config.js";
-export { DEFAULT_REPOSITORIES } from "./config.js";
-export { logger, setMCPLogCallback } from "./logger.js";
-export { MCPError, ErrorCodes, createUserError, formatErrorResponse, withErrorHandling, SelfCorrectionHints, } from "./errors.js";
-export { validateQuery, validateRepository, validatePath, validateRef, validateNumber, validateToolArgs, sanitizeString, } from "./validation.js";
-export type { ValidationResult } from "./validation.js";
-export { getHealthStatus, getQuickHealthStatus } from "./health.js";
-export type { HealthStatus } from "./health.js";
-export { updateRateLimitFromHeaders, updateRateLimit, getRateLimitStatus, shouldProceedWithRequest, getTimeUntilReset, formatRateLimitStatus, decrementRemaining, } from "./rate-limit.js";
-export type { RateLimitInfo, RateLimitStatus } from "./rate-limit.js";
-export { Cache, createCacheKey, searchCache, fileCache, metadataCache, pruneAllCaches, } from "./cache.js";
-export type { CacheOptions, CacheEntry, CacheStats } from "./cache.js";
-export { searchCompactHosted, searchTypeScriptHosted, searchDocsHosted, searchHosted, checkHostedApiHealth, getHostedApiStats, trackToolCall, } from "./hosted-api.js";
-export type { HostedSearchResult, HostedSearchResponse, HostedSearchFilter, } from "./hosted-api.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.js

@@ -1,15 +0,0 @@
-export { config, isHostedMode, isLocalMode } from "./config.js";
-export { DEFAULT_REPOSITORIES } from "./config.js";
-export { logger, setMCPLogCallback } from "./logger.js";
-export { MCPError, ErrorCodes, createUserError, formatErrorResponse, withErrorHandling, SelfCorrectionHints, } from "./errors.js";
-// Validation utilities
-export { validateQuery, validateRepository, validatePath, validateRef, validateNumber, validateToolArgs, sanitizeString, } from "./validation.js";
-// Health check utilities
-export { getHealthStatus, getQuickHealthStatus } from "./health.js";
-// Rate limit tracking
-export { updateRateLimitFromHeaders, updateRateLimit, getRateLimitStatus, shouldProceedWithRequest, getTimeUntilReset, formatRateLimitStatus, decrementRemaining, } from "./rate-limit.js";
-// Caching utilities
-export { Cache, createCacheKey, searchCache, fileCache, metadataCache, pruneAllCaches, } from "./cache.js";
-// Hosted API client
-export { searchCompactHosted, searchTypeScriptHosted, searchDocsHosted, searchHosted, checkHostedApiHealth, getHostedApiStats, trackToolCall, } from "./hosted-api.js";
-//# sourceMappingURL=index.js.map

package/dist/utils/logger.d.ts

@@ -1,48 +0,0 @@
-type LogLevel = "debug" | "info" | "warn" | "error";
-type LogFormat = "text" | "json";
-type MCPLogCallback = (level: "debug" | "info" | "notice" | "warning" | "error", logger: string, data: unknown) => void;
-/**
- * Set the MCP log callback to send logs to the client
- */
-export declare function setMCPLogCallback(callback: MCPLogCallback | null): void;
-declare class Logger {
-    private level;
-    private format;
-    private service;
-    constructor(level?: LogLevel, format?: LogFormat, service?: string);
-    /**
-     * Set log format at runtime
-     */
-    setFormat(format: LogFormat): void;
-    /**
-     * Set log level at runtime
-     */
-    setLevel(level: LogLevel): void;
-    private shouldLog;
-    private formatTextMessage;
-    private formatJsonMessage;
-    private formatMessage;
-    debug(message: string, meta?: object): void;
-    info(message: string, meta?: object): void;
-    warn(message: string, meta?: object): void;
-    error(message: string, meta?: object): void;
-    /**
-     * Create a child logger with additional context
-     */
-    child(context: object): ChildLogger;
-}
-/**
- * Child logger that includes additional context in all log messages
- */
-declare class ChildLogger {
-    private parent;
-    private context;
-    constructor(parent: Logger, context: object);
-    debug(message: string, meta?: object): void;
-    info(message: string, meta?: object): void;
-    warn(message: string, meta?: object): void;
-    error(message: string, meta?: object): void;
-}
-export declare const logger: Logger;
-export {};
-//# sourceMappingURL=logger.d.ts.map

package/dist/utils/logger.js

@@ -1,124 +0,0 @@
-import { config } from "./config.js";
-// Global MCP log callback (set by server)
-let mcpLogCallback = null;
-/**
- * Set the MCP log callback to send logs to the client
- */
-export function setMCPLogCallback(callback) {
-    mcpLogCallback = callback;
-}
-const LOG_LEVELS = {
-    debug: 0,
-    info: 1,
-    warn: 2,
-    error: 3,
-};
-class Logger {
-    level;
-    format;
-    service;
-    constructor(level = "info", format = "text", service = "midnight-mcp") {
-        this.level = level;
-        this.format = format;
-        this.service = service;
-    }
-    /**
-     * Set log format at runtime
-     */
-    setFormat(format) {
-        this.format = format;
-    }
-    /**
-     * Set log level at runtime
-     */
-    setLevel(level) {
-        this.level = level;
-    }
-    shouldLog(level) {
-        return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
-    }
-    formatTextMessage(level, message, meta) {
-        const timestamp = new Date().toISOString();
-        const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
-        return `[${timestamp}] [${level.toUpperCase()}] ${message}${metaStr}`;
-    }
-    formatJsonMessage(level, message, meta) {
-        const entry = {
-            timestamp: new Date().toISOString(),
-            level,
-            message,
-            service: this.service,
-        };
-        if (meta) {
-            entry.meta = meta;
-        }
-        return JSON.stringify(entry);
-    }
-    formatMessage(level, message, meta) {
-        if (this.format === "json") {
-            return this.formatJsonMessage(level, message, meta);
-        }
-        return this.formatTextMessage(level, message, meta);
-    }
-    debug(message, meta) {
-        if (this.shouldLog("debug")) {
-            console.error(this.formatMessage("debug", message, meta));
-        }
-        // Also send to MCP client
-        mcpLogCallback?.("debug", this.service, { message, ...meta });
-    }
-    info(message, meta) {
-        if (this.shouldLog("info")) {
-            console.error(this.formatMessage("info", message, meta));
-        }
-        // Also send to MCP client
-        mcpLogCallback?.("info", this.service, { message, ...meta });
-    }
-    warn(message, meta) {
-        if (this.shouldLog("warn")) {
-            console.error(this.formatMessage("warn", message, meta));
-        }
-        // Also send to MCP client (MCP uses "warning" not "warn")
-        mcpLogCallback?.("warning", this.service, { message, ...meta });
-    }
-    error(message, meta) {
-        if (this.shouldLog("error")) {
-            console.error(this.formatMessage("error", message, meta));
-        }
-        // Also send to MCP client
-        mcpLogCallback?.("error", this.service, { message, ...meta });
-    }
-    /**
-     * Create a child logger with additional context
-     */
-    child(context) {
-        return new ChildLogger(this, context);
-    }
-}
-/**
- * Child logger that includes additional context in all log messages
- */
-class ChildLogger {
-    parent;
-    context;
-    constructor(parent, context) {
-        this.parent = parent;
-        this.context = context;
-    }
-    debug(message, meta) {
-        this.parent.debug(message, { ...this.context, ...meta });
-    }
-    info(message, meta) {
-        this.parent.info(message, { ...this.context, ...meta });
-    }
-    warn(message, meta) {
-        this.parent.warn(message, { ...this.context, ...meta });
-    }
-    error(message, meta) {
-        this.parent.error(message, { ...this.context, ...meta });
-    }
-}
-// Determine log format from environment
-const logFormat = process.env.LOG_FORMAT === "json" ? "json" : "text";
-export const logger = new Logger(config.logLevel, logFormat);
-//# sourceMappingURL=logger.js.map

package/dist/utils/rate-limit.d.ts

@@ -1,61 +0,0 @@
-/**
- * Rate limit tracking and management utilities
- * Tracks GitHub API rate limits and warns before hitting limits
- */
-export interface RateLimitInfo {
-    limit: number;
-    remaining: number;
-    reset: Date;
-    used: number;
-}
-export interface RateLimitStatus {
-    isLimited: boolean;
-    isWarning: boolean;
-    remaining: number;
-    limit: number;
-    resetAt: Date;
-    percentUsed: number;
-    message: string;
-}
-/**
- * Update rate limit info from API response headers
- */
-export declare function updateRateLimitFromHeaders(headers: Record<string, string | undefined>): void;
-/**
- * Update rate limit info directly
- */
-export declare function updateRateLimit(info: RateLimitInfo): void;
-/**
- * Get current rate limit status
- */
-export declare function getRateLimitStatus(): RateLimitStatus;
-/**
- * Check if we should proceed with an API call
- * Returns true if safe to proceed, false if we should wait/fail
- */
-export declare function shouldProceedWithRequest(): {
-    proceed: boolean;
-    reason?: string;
-    waitMs?: number;
-};
-/**
- * Get time until rate limit resets
- */
-export declare function getTimeUntilReset(): number;
-/**
- * Check if cached rate limit info is stale
- */
-export declare function isRateLimitStale(): boolean;
-/**
- * Get cached rate limit info
- */
-export declare function getCachedRateLimit(): RateLimitInfo | null;
-/**
- * Decrement remaining count (for optimistic tracking)
- */
-export declare function decrementRemaining(): void;
-/**
- * Format rate limit status for display
- */
-export declare function formatRateLimitStatus(): string;
-//# sourceMappingURL=rate-limit.d.ts.map